Provided by: manpages-it_4.23.1-1_all bug

NOME

       bash - GNU Bourne-Again SHell

SINTASSI

       bash [opzioni] [stringa_di_comando | file]

COPYRIGHT

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

DESCRIZIONE

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

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

OPZIONI

       Tutte  le  opzioni  monocarattere  della  shell  documentate nella descrizione del comando
       incorporato set, compreso  -o, possono essere  usate  come  opzioni  quando  la   shell  è
       invocata. In aggiunta, quando è invocata, bash interpreta le seguenti opzioni:

       -c        Se  è  presente  l'opzione  -c,  i comandi sono letti dal primo argomento non di
                 opzione stringa_di_comando.Se vi sono argomenti dopo la stringa_di_comando, essi
                 sono assegnati ai parametri posizionali, partendo da $0, e i rimanenti argomenti
                 vengono assegnati ai parametri posizionali.  L'assegnamento  a   $0  imposta  il
                 nome della shell, che è usato nei messaggi di avvertimento e di errore.
       -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 o si legge l'input tramite una pipe.
       -v        Stampa le righe in input alla shell appena sono lette.
       -x        Stampa comandi e i loro argomenti così come vengono eseguiti.
       -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 nomifile e argomenti. Un
                 argomento di - è equivalente a --.

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

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

       --login
              Equivalente a -l.

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

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

       --norc Non   legge   né  esegue  il  file   file  d'inizializzazione  generale  di  sitema
              /etc/bash.bashrc e il  personale  di  inizializzazione  ~/.bashrc  se  la  shell  è
              interattiva.  Quest'opzione  è  attiva  per  impostazione predefinita se la shell è
              invocata come sh.

       --posix
              Cambia il comportamento di bash dove le operazioni predefinite  differiscono  dallo
              standard  POSIX, in modo da corrispondere allo standard (modalità posix).   Si veda
              più avanti VEDERE ANCHE dove viene citato un documento  che  spiega  nel  dettaglio
              come la modalità posix influenza il comportamento di bash.

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

       --verbose
              Equivalente a -v.

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

ARGOMENTI

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

INVOCAZIONE

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

       An  interactive shell is one started without non-option arguments (unless -s is specified)
       and without the -c option, whose standard input and error are both connected to  terminals
       (as  determined  by  isatty(3)),  or  one  started  with the -i option.  PS1 is set and $-
       includes i if bash is interactive, allowing a shell script or a startup file to test  this
       state.

       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  nomifile  come  descritto più avanti in 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 interattiva esce, o una shell di login non interattiva esegue il
       comando incorporato exit, 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  e   ~/.bashrc,  se  quei  file  esistono.  Ciò  può essere inibito
       utilizzando l'opzione --norc.  Con l'opzione --rcfile file bash legge ed esegue comandi da
       file invece che da  /etc/bash.bashrc  e ~/.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-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 attempts to determine when it is being run with its standard  input  connected  to  a
       network  connection, as when executed by the historical remote shell daemon, usually rshd,
       or the secure shell daemon sshd.  If bash determines it is being run non-interactively  in
       this fashion, it reads and executes commands from /etc/bash.bashrc and ~/.bashrc, if these
       files exist and are readable.  It will not do this if invoked as sh.   The  --norc  option
       may be used to inhibit this behavior, and the --rcfile option may be used to force another
       file to be read, but neither rshd nor sshd generally invoke the shell with  those  options
       or allow them to be specified.

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

DEFINIZIONI

       Le seguenti definizioni sono usate nel resto di questo documento.
       blank  Uno spazio o carattere di tabulazione (tab).
       parola Una  sequenza  di  caratteri  considerata  come una singola unità dalla shell. Nota
              anche come token.
       nome   Una  parola  che  consiste  solo  di   caratteri   alfanumerici   e   trattini   di
              sottolineatura,   e   comincia  con  un  carattere  alfabetico  o  un  trattino  di
              sottolineatura. Definita anche un identificatore.
       metacarattere
              Un carattere che, quando non quotato, separa le parole. Uno dei seguenti:
              |  & ; ( ) < > space tab newline
       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  (si veda GRAMMATICA DELLA SHELL più avanti) , la terza parola di  un
       comando  case  o  select  (  è  valida solo in), o la terza parola di un comando for (sono
       valide solo in e do):

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

GRAMMATICA DELLA SHELL

       This section describes the syntax of the various forms of shell commands.

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

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

   Pipeline
       Una  pipeline  è  una  sequenza  di  uno  o più comandi separati da uno degli operatori di
       controllo | o |&. Il formato per una pipeline è:

              [time [-p]] [ ! ] command1 [ [||&] command2 ... ]

       The standard output of command1 is connected via a pipe to the standard input of command2.
       This  connection  is  performed  before  any  redirections  specified  by the command1(see
       REDIRECTION below).  If |& is used, command1's standard error, in addition to its standard
       output,  is  connected  to command2's standard input through the pipe; it is shorthand for
       2>&1 |.  This implicit redirection of  the  standard  error  to  the  standard  output  is
       performed after any redirections specified by command1.

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

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

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

       Each command in a multi-command pipeline, where  pipes  are  created,  is  executed  in  a
       subshell,  which  is  a  separate  process.   See  COMMAND  EXECUTION  ENVIRONMENT  for  a
       description of subshells and a subshell environment.  If the lastpipe  option  is  enabled
       using  the  shopt  builtin  (see  the  description  of shopt below), the last element of a
       pipeline may be run by the shell process when job control is not active.

   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.   Questi  sono  detti  comandi  asincroni.  I comandi separati da un ; sono
       eseguiti sequenzialmente; la shell aspetta che ogni comando,  in  sequenza,  termini.   Lo
       stato di ritorno è lo stato d'uscita dell'ultimo comando eseguito.

       Le  liste  AND  e  OR sono sequenze di una o più pipeline separate, rispettivamente, dagli
       operatori di controllo && e ||. Le liste AND e OR vengono  eseguite  con  associatività  a
       sinistra. Una lista AND ha la forma

              comando1 && comando2

       comando2  è  eseguito  se,  e  solo  se,  comando1  restituisce uno stato d'uscita di zero
       (successo).

       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.  Nella maggior parte dei casi  una  lista  in  una
       descrizione  di  comando può essere separata dal resto del comando da uno o più newline, e
       può essere seguita da un newline al posto di un punto e virgola.

       (lista)
              list is executed in a subshell (see  COMMAND  EXECUTION  ENVIRONMENT  below  for  a
              description  of a subshell environment).  Variable assignments and builtin commands
              that affect the shell's environment do not  remain  in  effect  after  the  command
              completes.  The return status is the exit status of list.

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

       ((espressione))
              The expression is evaluated according to the rules described below under ARITHMETIC
              EVALUATION.  If the value of the expression is non-zero, the return  status  is  0;
              otherwise  the return status is 1.  The expression undergoes the same expansions as
              if it were within double quotes, but double quote characters in expression are  not
              treated specially and are removed.

       [[ espressione ]]
              Return a status of 0 or 1 depending on the evaluation of the conditional expression
              expression.  Expressions are  composed  of  the  primaries  described  below  under
              CONDITIONAL  EXPRESSIONS.   The  words  between  the  [[ and ]] do not undergo word
              splitting and pathname expansion.  The shell performs  tilde  expansion,  parameter
              and   variable  expansion,  arithmetic  expansion,  command  substitution,  process
              substitution, and quote removal on those words (the expansions that would occur  if
              the  words  were enclosed in double quotes).  Conditional operators such as -f must
              be unquoted to be recognized as primaries.

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

       Si  veda  la  descrizione del comando incorporato  test (sezione COMANDI INCORPORATI DELLA
       SHELL più avanti) per la gestione di parametri (cioè parametri mancanti).

       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, come se fosse abilitata l'opzione di shell extglob.  L'operatore
       =  è  eqiovalente  a  ==.   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.

       An  additional  binary  operator, =~, is available, with the same precedence as == and !=.
       When it is used, the string to the right of the operator is considered  a  POSIX  extended
       regular expression and matched accordingly (using the POSIX regcomp and regexec interfaces
       usually described in regex(3)).  The return value is 0 if the string matches the  pattern,
       and  1  otherwise.   If the regular expression is syntactically incorrect, the conditional
       expression's return value is 2.  If the nocasematch shell option is enabled, the match  is
       performed without regard to the case of alphabetic characters.  If any part of the pattern
       is quoted, the quoted portion is matched literally.  This means  every  character  in  the
       quoted portion matches itself, instead of having any special pattern matching meaning.  If
       the pattern is stored in a shell variable,  quoting  the  variable  expansion  forces  the
       entire  pattern to be matched literally.  Treat bracket expressions in regular expressions
       carefully, since normal  quoting  and  pattern  characters  lose  their  meanings  between
       brackets.

       The pattern will match if it matches any part of the string.  Anchor the pattern using the
       ^ and $ regular expression operators to force it to match the entire  string.   The  array
       variable  BASH_REMATCH records which parts of the string matched the pattern.  The element
       of BASH_REMATCH with index 0 contains the  portion  of  the  string  matching  the  entire
       regular expression.  Substrings matched by parenthesized subexpressions within the regular
       expression are saved in the remaining BASH_REMATCH indices. The  element  of  BASH_REMATCH
       with  index  n  is the portion of the string matching the nth parenthesized subexpression.
       Bash sets BASH_REMATCH in the global scope; declaring it as a local variable will lead  to
       unexpected results.

       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 (( espr1 ; espr2 ; espr3 )) ; do lista ; done
              Prima  viene  valutata  l'espressione  aritmetica  espr1  in  accordo con le regole
              descritte  più  avanti  sotto  VALUTAZIONE  ARITMETICA.   Viene   quindi   valutata
              ripetutamente l'espressione aritmetica espr2 finché non assume il valore zero. Ogni
              volta che espr2 è diverso da zero, lista viene eseguita e l'espressione  aritmetica
              espr3  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
              The list of words following in is expanded, generating a list of items, and the set
              of expanded words is printed on the standard error, each preceded by a number.   If
              the  in  word  is  omitted,  the  positional parameters are printed (see PARAMETERS
              below).  select then displays the PS3 prompt and reads a  line  from  the  standard
              input.   If  the  line  consists  of a number corresponding to one of the displayed
              words, then the value of name is set to that word.  If the line is empty, the words
              and  prompt  are displayed again.  If EOF is read, the select command completes and
              returns 1.  Any other value read causes name to be set to null.  The line  read  is
              saved  in  the  variable  REPLY.  The list is executed after each selection until a
              break command is executed.  The exit status of select is the  exit  status  of  the
              last command executed in list, or zero if no commands were executed.

       case parola in [ [(] modello [ | modello ] ... ) lista ;; ] ... esac
              A  case  command  first expands word, and tries to match it against each pattern in
              turn, using the matching rules described under Pattern Matching below.  The word is
              expanded  using  tilde  expansion,  parameter  and  variable  expansion, arithmetic
              expansion, command substitution, process  substitution  and  quote  removal.   Each
              pattern  examined  is  expanded  using  tilde  expansion,  parameter  and  variable
              expansion, arithmetic expansion, command substitution,  process  substitution,  and
              quote  removal.  If the nocasematch shell option is enabled, the match is performed
              without regard to the case of alphabetic characters.  When a match  is  found,  the
              corresponding  list is executed.  If the ;; operator is used, no subsequent matches
              are attempted after the first pattern match.   Using  ;&  in  place  of  ;;  causes
              execution  to  continue  with  the  list  associated with the next set of patterns.
              Using ;;& in place of ;; causes the shell to test the  next  pattern  list  in  the
              statement,  if  any,  and  execute  any  associated  list  on  a  successful match,
              continuing the case statement execution as if the pattern  list  had  not  matched.
              The exit status is zero if no pattern matches.  Otherwise, it is the exit status of
              the last command executed in list.

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

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

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

       The syntax for a coprocess is:

              coproc [NOME] comando [ridirezioni]

       This creates a coprocess named NAME.  command may be either a simple command or a compound
       command (see above).  NAME is a shell variable name.  If NAME is not supplied, the default
       name is COPROC.

       The recommended form to use for a coprocess is

              coproc NAME { command [redirections]; }

       This form is recommended because simple commands result  in  the  coprocess  always  being
       named COPROC, and it is simpler to use and more complete than the other compound commands.

       If  command  is a compound command, NAME is optional. The word following coproc determines
       whether that word is interpreted as a variable name: it is interpreted as NAME  if  it  is
       not  a  reserved word that introduces a compound command.  If command is a simple command,
       NAME is not allowed; this is to avoid confusion between NAME and the  first  word  of  the
       simple command.

       When  the  coprocess  is  executed, the shell creates an array variable (see Arrays below)
       named NAME in the context of the executing shell.   The  standard  output  of  command  is
       connected via a pipe to a file descriptor in the executing shell, and that file descriptor
       is assigned to NAME[0].  The standard input of command is connected via a pipe to  a  file
       descriptor  in the executing shell, and that file descriptor is assigned to NAME[1].  This
       pipe is established before any redirections specified  by  the  command  (see  REDIRECTION
       below).   The  file  descriptors  can  be  utilized  as  arguments  to  shell commands and
       redirections using standard word expansions.  Other than those created to execute  command
       and process substitutions, the file descriptors are not available in subshells.

       The  process ID of the shell spawned to execute the coprocess is available as the value of
       the variable NAME_PID.  The wait builtin command may be used to wait for the coprocess  to
       terminate.

       Poiché il coprocesso è creato come comando asincrono, il comando coproc restituisce sempre
       successo.  Lo stato di ritorno di un coprocesso è lo stato di ritorno di comando.

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

       fname () comando-composto [ridirezione]
       function fname [()] comando-composto [ridirezione]
              This defines a function named fname.  The reserved word function is  optional.   If
              the  function reserved word is supplied, the parentheses are optional.  The body of
              the function is  the  compound  command  compound-command  (see  Compound  Commands
              above).  That command is usually a list of commands between { and }, but may be any
              command listed under Compound Commands above.  If the  function  reserved  word  is
              used,   but   the  parentheses  are  not  supplied,  the  braces  are  recommended.
              compound-command is executed whenever fname is specified as the name  of  a  simple
              command.   When  in posix mode, fname must be a valid shell name and may not be the
              name of one of the POSIX special builtins.  In default mode, a function name can be
              any unquoted shell word that does not contain $.  Any redirections (see REDIRECTION
              below) specified when a function is defined are  performed  when  the  function  is
              executed.   The  exit status of a function definition is zero unless a syntax error
              occurs or a readonly function with the same name already  exists.   When  executed,
              the  exit  status  of a function is the exit status of the last command executed in
              the body.  (See FUNCTIONS below.)

COMMENTI

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

QUOTATURA

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

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

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

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

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

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

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

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

       Character  sequences  of  the  form  $'string'  are treated as a special variant of single
       quotes.  The sequence expands to  string,  with  backslash-escaped  characters  in  string
       replaced as specified by the ANSI C standard.  Backslash escape sequences, if present, are
       decoded as follows:
              \a     avviso (segnale acustico)
              \b     backspace
              \e
              \E     un carattere di escape
              \f     salto pagina
              \n     codice di fine riga (newline)
              \r     ritorno carrello
              \t     tabulazione orizzontale
              \v     tabulazione verticale
              \\     barra inversa
              \'     apostrofo
              \"     virgolette
              \?     punto interrogativo
              \nnn   il carattere a otto bit il cui valore è il valore ottale nnn (da una  a  tre
                     cifre ottali)
              \xHH   il  carattere a otto bit il cui valore è il valore esadecimale HH (una o due
                     cifre esadecimali)
              \uHHHH il carattere Unicode (ISO/IEC 10646) il cui valore è il  valore  esadecimale
                     HHHH (da una a quattro cifre esadecimali)
              \UHHHHHHHH
                     il  carattere  Unicode (ISO/IEC 10646) il cui valore è il valore esadecimale
                     HHHHHHHH (da una a otto cifre esadecimali)
              \cx    un carattere control-x

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

       A  double-quoted string preceded by a dollar sign ($"string")  will cause the string to be
       translated according to the current  locale.   The  gettext  infrastructure  performs  the
       lookup  and  translation,  using  the  LC_MESSAGES,  TEXTDOMAINDIR,  and  TEXTDOMAIN shell
       variables.  If the current locale is C or POSIX, if there are no  translations  available,
       or  if the string is not translated, the dollar sign is ignored.  This is a form of double
       quoting, so the string remains double-quoted by default, whether or not it  is  translated
       and  replaced.   If  the  noexpand_translation  option is enabled using the shopt builtin,
       translated strings are single-quoted instead of double-quoted.   See  the  description  of
       shopt below under SHELLBUILTINCOMMANDS.

PARAMETRI

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

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

       Una variabile può essere assegnata da una istruzione della forma

              nome=[valore]

       If value is not given, the variable is assigned the null string.  All values undergo tilde
       expansion, parameter and variable expansion, command substitution,  arithmetic  expansion,
       and  quote  removal (see EXPANSION below).  If the variable has its integer attribute set,
       then value is evaluated as an arithmetic expression even if the $((...))  expansion is not
       used  (see  Arithmetic  Expansion  below).   Word splitting and pathname expansion are not
       performed.  Assignment statements may also appear as  arguments  to  the  alias,  declare,
       typeset,  export,  readonly,  and  local builtin commands (declaration commands).  When in
       posix mode, these builtins may appear in a command after one  or  more  instances  of  the
       command builtin and retain these assignment statement properties.

       In  the  context where an assignment statement is assigning a value to a shell variable or
       array index, the += operator can be used to append to or add to  the  variable's  previous
       value.  This includes arguments to builtin commands such as declare that accept assignment
       statements (declaration commands).  When += is applied to a variable for which the integer
       attribute  has  been  set, value is evaluated as an arithmetic expression and added to the
       variable's current value, which is also  evaluated.   When  +=  is  applied  to  an  array
       variable  using  compound assignment (see Arrays below), the variable's value is not unset
       (as it is when using =), and new values are appended to the array beginning at one greater
       than the array's maximum index (for indexed arrays) or added as additional key-value pairs
       in an associative array.  When applied to a string-valued variable, value is expanded  and
       appended to the variable's value.

       A  una  variabile  può  essere  assegnato l'attributo nameref con l'opzione -n dei comandi
       incorporati declare o local (si veda più avanti la descrizione di  declare  e  local)  per
       creare  un  nameref, o un riferimento a un'altra variabile.  Questo permette di manipolare
       le variabili indirettamente.  Ogni volta che la variabile  nameref  è  referenziata  o  ha
       avuto  un assegnamento, l'operazione è eseguita effettivamente sulla variabile specificata
       dal valore della variabile nameref. Un nameref è usato comunemente all'interno di funzioni
       di  shell  per  far  riferimento a una variabile il cui nome è passato come argomento alla
       funzione. Per esempio, se un nome di variabile è passato alla funzione di  shell  come  il
       suo primo argomento, eseguendo
              declare -n ref=$1
       all'interno  della  funzione  crea una variabile nameref ref il cui valore è il nome della
       variabile passato al primo argomento. Riferimenti e assegnamenti a ref sono trattati  come
       riferimenti  e  assegnamenti   alla  variabile  il cui nome è stato passato come $1. Se la
       variabile di controllo in un ciclo for ha l'attributo nameref,  la  lista  di  parole  può
       essere  una  lista  di variabili di shell, e verrà costituito un riferimento nome per ogni
       parola della lista, a turno, quando viene eseguito il ciclo.  Alle variabili array  non  è
       possibile  dare  l'attributo  -n. Comunque, le variabili nameref possono far riferimento a
       variabili array e a variabili array indicizzate. I nameref possono essere annullati usando
       l'opzione  -n del comando incorporato unset.  Altrimenti, se unset viene eseguito col nome
       di una variabile nameref come argomento, la variabile a cui fa  riferimento  la  variabile
       nameref verrà annullata.

   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  non
              è  tra virgolette, ogni parametro posizionale si espande in una parola separata. In
              contesti in cui è effettuata, queste parole sono soggette a successiva suddivisione
              in  parole  ed espansione di percorso.  Quando l'espansione avviene tra virgolette,
              si espande in una singola parola contenente il valore di ciascun parametro separato
              dagli  altri  dal  primo  carattere  della  variabile  speciale  IFS.  Cioè, "$*" è
              equivalente a "$1c$2c...", dove c è il primo carattere del valore  della  variabile
              IFS.  Se IFS viene annullata, i parametri sono separati da spazi. Se IFS è nulla, i
              parametri sono uniti senza alcun separatore.
       @      Si espande nei parametri posizionali, a partire dal primo.  In contesti  in  cui  è
              effettuata  la suddiviisone in parole, questo espande ogni parametro posizionale in
              una parola separata; se non è no è tra virgolette, queste parole  sono  soggette  a
              suddivisione  in  parole   In  contesti  in cui non è effettuata la suddivisione in
              parole. questo si  espande  una  parola  singola  con  ogni  parametro  posizionale
              separato  da spazio.  Quando l'espansione avviene tra virgolette, ogni parametro si
              espande in una parola separata. Cioè,  "$@"  è  equivalente  a  "$1"  "$2"  ...  Se
              l'espansione  fra  virgolette  avviene  all'interno di una parola, l'espansione del
              primo  parametro  è  unita  con  la  parte  iniziale  della  parola  originale,   e
              l'espansione  dell'ultimo  parametro  è  unita  con  la  parte  finale della parola
              originale. Quando non vi è alcun parametro posizionale, "$@" e $@ si espandono come
              stringa nulla (cioè, sono rimossi).
       #      Si espande nel numero di parametri posizionali espresso come numero decimale.
       ?      Si  espande  nello  stato  di uscita della pipeline eseguita più recentemente senza
              rilasciare il controllo del terminale.
       -      Si espande nei flag di opzione correnti come specificato in base alla chiamata, dal
              comando  incorporato  set, o in quelli impostati dalla shell stessa (come l'opzione
              -i).
       $      Expands to the process ID of the shell. In a subshell, it expands to the process ID
              of the current shell, not the subshell.
       !      Si  espande  nell'ID  di  processo del job più recentemente messo in background, se
              eseguito come comando asincrono o usando il comando incorporato  bg  (si  veda  JOB
              CONTROL  più avanti).
       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  nome-file  usato  per  chiamare  bash,  come  dato
              dall'argomento zero.

   Variabili di shell
       Le seguenti variabili sono impostate dalla shell:

       _      All'avvio della shell, impostato al nome di percorso 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
              semplice  eseguito  inprimo  piano,  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.
       BASH   Si espande al nome-file completo usato per chiamare questa istanza di bash.
       BASHOPTS
              Una lista di opzioni di shell abilitate separate da un due punti. Ogni parola della
              lista è un argomento valido per l'opzione -s del comando incorporato shopt (si veda
              COMANDI INCORPORATI DELLA SHELL più avanti). Le opzioni che  appaiono  in  BASHOPTS
              sono  quelle  contrassegnate  come on da shopt. Se questa variabile è nell'ambiente
              quando bash viene avviato, ogni opzione di shell nella lista sarà  abilitata  prima
              della lettura di qualsiasi file di avvio. Questa variabile è di sola lettura.
       BASHPID
              Espande  all'ID  del  processo  dell'attuale  bash. In determinate circostanze, ciò
              differisce da $$, come nel caso  di  subshell  che  non  richiedono  che  bash  sia
              reinizializzato.   Assegnamenti  a  BASHPID  non  hanno  alcun effetto.  Se BASHPID
              viene annullata, perde le sue proprietà speciali, anche se è poi reimpostata.
       BASH_ALIASES
              Una variabile array associativa i cui elementi corrispondono alla lista interna  di
              alias come conservati dal comando incorporato alias. Gli elementi aggiunti a questo
              array appaiono nella lista degli  alias;  comunque,  togliendo  elementi  all'array
              attualmente  gli  alias  non  vengono  rimossi  dalla lista. Se BASH_ALIASES  viene
              annullata, perde le sue proprietà speciali, anche se è poi reimpostata.
       BASH_ARGC
              Una variabile array i cui valori sono il numero di  parametri  in  ogni  frame  del
              corrente  stack  delle chiamate di esecuzione di bash. Il numero di parametri della
              subroutine corrente (funzione di shell o script eseguito con . o source) è in  cima
              allo  stack. Quando viene eseguita una subroutine, il numero di parametri passati è
              messo in cima a BASH_ARGC. La shell imposta BASH_ARGC solo  quando  è  in  modalità
              estesa  di  debugging  (si veda la descrizione dell'opzione extdebug per il comando
              incorporato shopt più avanti).  Impostare extdebug dopo che la shell  ha iniziato a
              eseguire  uno  script,  o  referenziare  questa  variabile  quando  extdebug  non è
              impostato,  può dar luogo a valori incongruenti.
       BASH_ARGV
              Una variabile array contenente tutti i parametri nel corrente stack delle  chiamate
              di  esecuzione di bash. Il parametro finale dell'ultima chiamata di subroutine è in
              cima allo stack; il primo parametro della chiamata iniziale è in fondo. Quando  una
              subroutine  viene  eseguita, i parametri forniti sono messi in cima a BASH_ARGV. La
              shell imposta BASH_ARGV solo quando è in modalità estesa di debugging (si  veda  la
              descrizione  dell'opzione  extdebug  al  comando  incorporato  shopt  più  avanti).
              Impostare extdebug dopo che  la  shell   ha  iniziato  a  eseguire  uno  script,  o
              referenziare  questa  variabile  quando extdebug  non è impostato,  può dar luogo a
              valori incongruenti.
       BASH_ARGV0
              Quando referenziata, questa variabile espande nel nome  della  shell  o  script  di
              shell  (identico  a  $0;  si  veda  sopra la descrizione del parametro speciale 0).
              L'assegnamento a BASH_ARGV0 fa si che il vaqlore assegnato sia  assegnato  anche  a
              $0.  Se BASH_ARGV0 viene annullata, perde le sue proprietà speciali, anche se è poi
              reimpostata.
       BASH_CMDS
              Un variabile array associativa i  cui  elementi  corrispondono  alla  tabella  hash
              interna  di  comandi  come  memorizzati  dal comando incorporato hash. Gli elementi
              aggiunti a questo array appaiono nella tabella hash; comunque,  togliendo  elementi
              all'array  attualmente  i  nomi dei comandi non saranno rimossi dalla tabella hash.
              Se BASH_CMDS non  è  impostata,  perde  le  sue  proprietà  speciali,  anche  se  è
              successivamente annullata.
       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. Se BASH_COMMAND  viene  annullata,  perde  le  sue  proprietà
              speciali, anche se è poi reimpostata.
       BASH_EXECUTION_STRING
              L'argomento per il comando all'invocazione dell'opzione -c.
       BASH_LINENO
              Una  variabile  array i cui elementi sono i numeri di riga nei file di origine dove
              ogni elemento corrispondente di FUNCNAME è stato chiamato. ${BASH_LINENO[$i]} è  il
              numero  di  riga  nel file di origine (${BASH_SOURCE[$i+1]}) dove ${FUNCNAME[$i]} è
              stato chiamato (o ${BASH_LINENO[$i-1]}  se  referenziato  all'interno  di  un'altra
              funzione di shell). Usare LINENO per ottenere il numero di riga corrente.
       BASH_LOADABLES_PATH
              Un elenco di directory, separate da due punti, nelle quali la shell cerca i comandi
              incorporato caricabili dinamicamente specificati dal comando enable.
       BASH_REMATCH
              Una variabile array i cui elementi sono  assegnati  dall'operatore  binario  =~  al
              comando  condizionale  [[.  L'elemento con indice 0 è la porzione della stringa che
              corrisponde all'intera espressione regolare. L'elemento con indice n è la  porzione
              della stringa che corrisponde alla n-sima sott-espressione fra parentesi.
       BASH_SOURCE
              Una  variabile array i cui elementi sono i nomifile dove sono definiti i nomi delle
              corrispondenti funzioni di shell nella variabile FUNCNAME.  La  funzione  di  shell
              ${FUNCNAME[$i]}   è   definita   nel  file  ${BASH_SOURCE[$i]}  ed  è  chiamata  da
              ${BASH_SOURCE[$i+1]}.
       BASH_SUBSHELL
              Incrementato di uno al'interno di ciascuna subshell o ambiente di  subshell  quando
              la  shell  inizia  a essere eseguita in quell'ambiente.  Il valore iniziale è 0. Se
              BASH_SUBSHELL  viene annullata, perde le sue proprietà speciali,  anche  se  è  poi
              reimpostata.
       BASH_VERSINFO
              Una  variabile  array  in  sola  lettura  i  cui  elementi danno informazioni sulla
              versione di quest'istanza di bash. I valori assegnati  ai  membri  dell'array  sono
              come segue:
              BASH_VERSINFO[0]        Il numero di versione principale (la release).
              BASH_VERSINFO[1]        Il numero di versione secondario (la versione).
              BASH_VERSINFO[2]        Il livello di aggiornamento tramite patch.
              BASH_VERSINFO[3]        La versione di compilazione.
              BASH_VERSINFO[4]        Lo stato della release (ad es., beta1).
              BASH_VERSINFO[5]        Il valore di MACHTYPE.
       BASH_VERSION
              Si espande in una stringa che descrive la versione di questa istanza di bash.
       COMP_CWORD
              Un  indice  in  ${COMP_WORDS}  della  parola  contenente  la posizione corrente del
              cursore. Questa variabile è disponibile solo nelle funzioni di shell invocate dalle
              risorse  di  completamento  programmabile  (si veda Completamento programmabile più
              avanti).
       COMP_KEY
              Il tasto (o il tasto finale di una sequenza) usato  per  invocare  la  funzione  di
              completamento corrente.
       COMP_LINE
              La  riga di comando corrente. Questa variabile è disponibile solo nelle funzioni di
              shell e nei comandi esterni invocati dai servizi di completamento programmabile (si
              veda Completamento programmabile più avanti).
       COMP_POINT
              L'indice  della  posizione  corrente  del  cursore  relativa all'inizio del comando
              corrente. Se la posizione corrente del cursore è alla fine del comando corrente, il
              valore di questa variabile è uguale a ${#COMP_LINE}. Questa variabile è disponibile
              solo  nelle  funzioni  di  shell  e  comandi  esterni  invocati  dai   servizi   di
              completamento programmabile (si veda Completamento programmabile più avanti).
       COMP_TYPE
              Impostata a un valore intero corrispondente al tipo di completamento tentato che ha
              causato la chiamata di una funzione di completamento:  TAB,  per  il  completamento
              normale,  ?,  per  l'elenco  dei  completamenti dopo tabulazioni successive, !, per
              l'elenco delle alternative di completamento di una parte di parola, @, per elencare
              i  completamenti  se  la  parola  non  ha  subito  modifiche,  o %, per il menù del
              completamento. Questa variabile è disponibile solo nelle funzioni di  shell  e  nei
              comandi  esterni  invocati  dai  servizi  di  completamento  programmabile (si veda
              Completamento programmabile più avanti).
       COMP_WORDBREAKS
              L'insieme dei caratteri che la libreria readline tratta come separatori  di  parola
              nell'effettuare  il  completamento  di  parola. Se COMP_WORDBREAKS viene annullata,
              perde le sue proprietà speciali, anche se è poi reimpostata.
       COMP_WORDS
              Una variabile array (si veda Array più avanti) che è composta dalle singole  parole
              nella  riga  di  comando  corrente.  La  riga  è  divisa in parole come readline la
              dividerebbe usando COMP_WORDBREAKS come descritto precedentemente. Questa variabile
              è  disponibile  solo nelle funzioni di shell e comandi esterni invocati dai servizi
              di completamento programmabile (si veda Completamento programmabile più avanti).
       COPROC Una variabile array (si veda Array più avanti) creata per contenere  i  descrittori
              di  file di uscita e di entrata di un coprocesso senza nome (si veda Coprocessi più
              avanti).
       DIRSTACK
              Una variabile array (si veda Array più avanti) che contiene il  contenuto  corrente
              dello  stack  delle directory. Le directory appaiono nello stack nell'ordine in cui
              sono mostrate dal comando incorporato dirs. L'assegnamento agli elementi di  questa
              variabile  array può essere usato per modificare le directory già nello stack, ma i
              comandi incorporati pushd e popd devono essere usati  per  aggiungere  e  rimuovere
              directory.  L'assegnamento  a questa variabile non cambia la directory corrente. Se
              DIRSTACK viene  annullata,  perde  le  sue  proprietà  speciali,  anche  se  è  poi
              reimpostata.
       EPOCHREALTIME
              Ogni  volta  che  questo  parametro  è referenziato, espande al numero di secondi a
              partire dall'epoca Unix (si veda time(3)) come valore in virgola mobile  con  grado
              di  frazionamento  di  microsecondi.   Gli  assegnamenti  a  EPOCHREALTIME  vengono
              ignorati.  Se EPOCHREALTIME viene annullata, perde le sue proprietà speciali, anche
              se è poi reimpostata.
       EPOCHSECONDS
              Ogni  volta  che  questo  parametro  è referenziato, espande a un numero di secondi
              trascorsi dall'epoca Unix (si veda time(3)).  Assegnamenti a  EPOCHSECONDS  vengono
              ignorati.  Se EPOCHSECONDS è annullata, perde le sue proprietà speciali, anche se è
              poi reimpostata.
       EUID   Espande all'ID-utente effettivo dell'utente corrente, inizializzata all'avvio della
              shell. Questa variabile è in sola lettura.
       FUNCNAME
              Una  variabile  array  contenente  i nomi di tutte le funzioni di shell attualmente
              nello stack delle chiamate di esecuzione. L'elemento con indice 0 è il  nome  della
              funzione  di  shell  attualmente  in  esecuzione.  L'elemento più in basso di tutti
              (quello con l'indice più alto) è "main".  Questa variabile esiste solo quando è  in
              esecuzione  una funzione di shell. Assegnamenti a FUNCNAME non hanno alcun effetto.
              Se FUNCNAME viene annullata, perde le  sue  proprietà  speciali,  anche  se  è  poi
              reimpostata.

              Questa  variabile  può essere usata con BASH_LINENO e BASH_SOURCE. Ogni elemento di
              FUNCNAME ha elementi corrispondenti in BASH_LINENO e BASH_SOURCE per descrivere  lo
              stack  delle  chiamate.  Per  esempio,  ${FUNCNAME[$i]}  è  stato chiamato dal file
              ${BASH_SOURCE[$i+1]} al numero di riga ${BASH_LINENO[$i]}. Il  comando  incorporato
              caller visualizza lo stack delle chiamate corrente usando questa informazione.
       GROUPS Una  variabile  array  contenente  l'elenco  dei gruppi dei quali è membro l'utente
              corrente. Assegnamenti a GROUPS non hanno alcun effetto. 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. Gi assegnamenti a HISTCMD vengono ignorati. Se HISTCMD  viene  annullata,
              perde le sue proprietà speciali, anche se è poi reimpostata.
       HOSTNAME
              Automaticamente impostata al nome dell'host corrente.
       HOSTTYPE
              Automaticamente  impostata  a  una  stringa  che  univocamente  descrive il tipo di
              macchina su cui bash è in  esecuzione.  Il  valore  predefinito  è  dipendente  dal
              sistema.
       LINENO Ogni  volta  che  questo  parametro  è referenziato, la shell gli assegna un numero
              decimale che rappresenta il numero di sequenza della riga corrente (partendo da  1)
              all'interno  di  uno  script o funzione. Quando non in uno script o funzione, non è
              garantito che il valore restituito sia significativo. Se  LINENO  viene  annullata,
              perde le sue proprietà speciali, anche se è poi reimpostata.
       MACHTYPE
              Automaticamente  impostata  a  una  stringa  che  descrive completamente il tipo di
              sistema  sul   quale   bash   è   in   esecuzione,   nel   formato   standard   GNU
              cpu-company-system. Il valore predefinito è dipendente dal sistema.
       MAPFILE
              Una  variabile array (si veda Array più avanti) creata per contenere il testo letto
              dal comando incorporato mapfile quando non viene fornito un nome di variabile.
       OLDPWD La precedente directory di lavoro come impostata dal comando cd.
       OPTARG Il valore dell'ultimo argomento opzione elaborato dal comando  incorporato  getopts
              (si veda COMANDI INCORPORATI DELLA SHELL più avanti).
       OPTIND L'indice  del  prossimo  argomento che dev'essere elaborato dal comando incorporato
              getopts (si veda COMANDI INCORPORATI DELLA SHELL più avanti).
       OSTYPE Automaticamente impostata a una stringa che descrive il sistema  operativo  su  cui
              bash è in esecuzione. Il valore predefinito è dipendente dal sistema.
       PIPESTATUS
              Una  variabile  array  (si veda Array più avanti) contenente un elenco di valori di
              stato d'uscita dai processi nelle pipeline eseguite più recentemente in primo piano
              [cioè  senza  rilasciare  il  controllo del terminale] (può contenere anche un solo
              comando).
       PPID   L'ID di processo del genitore della shell. Questa variabile è in sola lettura.
       PWD    La directory di lavoro corrente come impostata dal comando cd.
       RANDOM Ogni volta che questo parametro è referenziato,  si  espande  a  un  numero  intero
              casuale  fra 0 e 32767. Assegnando un valore a RANDOM viene inizializzata (seed) la
              sequenza di numeri casuali. Se RANDOM  viene  annullata,  perde  le  sue  proprietà
              speciali, anche se è poi reimpostata.
       READLINE_ARGUMENT
              Any  numeric  argument given to a readline command that was defined using "bind -x"
              (see SHELL BUILTIN COMMANDS below)  when it was invoked.
       READLINE_LINE
              Il contenuto del buffer di riga readline per l'uso con "bind -x" (si  veda  COMANDI
              INCORPORATI DELLA SHELL più avanti).
       READLINE_MARK
              La  posizione della marcatura (punto di inserzione) nel buffer di riga readline per
              l'uso con "bind -x" (si  veda  COMANDI  INCORPORATI  DELLA  SHELL  più  avanti).  I
              caratteri tra il punto d'inserzione e la marcatura vine chspesso chiamata regione.
       READLINE_POINT
              La  posizione  del  punto  di  inserzione nel buffer di riga readline per l'uso con
              "bind -x" (si veda COMANDI INCORPORATI DELLA SHELL più avanti).
       REPLY  Impostata alla riga di input letta  dal  comando  incorporato  read  quando  nessun
              argomento è specificato.
       SECONDS
              Each  time  this parameter is referenced, it expands to the number of seconds since
              shell invocation.  If a value is assigned  to  SECONDS,  the  value  returned  upon
              subsequent  references is the number of seconds since the assignment plus the value
              assigned.  The number of seconds at shell  invocation  and  the  current  time  are
              always  determined by querying the system clock.  If SECONDS is unset, it loses its
              special properties, even if it is subsequently reset.
       SHELLOPTS
              Una lista, separata da due punti, di opzioni di shell abilitate. Ogni parola  nella
              lista  è  un  argomento valido per l'opzione -o al comando incorporato set (si veda
              COMANDI INCORPORATI DELLA SHELL più avanti). Le opzioni che appaiono  in  SHELLOPTS
              sono  quelle indicate come on da set -o. Se questa variabile è nell'ambiente quando
              bash viene avviata, ogni opzione di shell nella  lista  viene  abilitata  prima  di
              leggere un qualsiasi file di avvio. Questa variabile è in sola lettura.
       SHLVL  È incrementato di uno ogni volta che una istanza di bash viene avviata.
       SRANDOM
              This  variable expands to a 32-bit pseudo-random number each time it is referenced.
              The random number generator is not linear on systems that support  /dev/urandom  or
              arc4random,  so  each  returned number has no relationship to the numbers preceding
              it.  The random number generator cannot be seeded, so assignments to this  variable
              have  no  effect.  If SRANDOM is unset, it loses its special properties, even if it
              is subsequently reset.
       UID    Si espande all'ID-utente dell'utente corrente, inizializzato all'avvio della shell.
              Questa variabile è in sola lettura.

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

       BASH_COMPAT
              The value is used to set the shell's compatibility level.  See SHELL  COMPATIBILITY
              MODE below for a description of the various compatibility levels and their effects.
              The  value  may  be  a  decimal  number  (e.g.,  4.2)  or  an  integer  (e.g.,  42)
              corresponding  to  the desired compatibility level.  If BASH_COMPAT is unset or set
              to the empty string, the compatibility level is set to the default for the  current
              version.   If  BASH_COMPAT  is  set  to  a  value  that  is  not  one  of the valid
              compatibility levels, the shell prints an error message and sets the  compatibility
              level  to  the default for the current version.  The valid values correspond to the
              compatibility levels described below under SHELL COMPATIBILITY MODE.  For  example,
              4.2  and  42  are valid values that correspond to the compat42 shopt option and set
              the compatibility level to 42.  The current version is also a valid value.
       BASH_ENV
              Se questo parametro è impostato quando bash sta eseguendo uno script di  shell,  il
              suo valore è interpretato come un nome-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-file.   PATH  non  è  usato  per  cercare  il  nome-file
              risultante.
       BASH_XTRACEFD
              Se  impostata  a  un  valore intero corrispondente a un descrittore di file valido,
              bash scriverà l'output della traccia generata quando set  -x  è  abilitato  a  quel
              descrittore di file. Il descrittore di file viene chiuso quando BASH_XTRACEFD non è
              impostata o  le  viene  assegnato  un  nuovo  valore.  Annullando  BASH_XTRACEFD  o
              assegnandole  una  stringa vuota l'output della traccia verrà inviato allo standard
              error. Da notare che impostando BASH_XTRACEFD a 2 (il  descrittore  di  file  dello
              standard error) e, successivamente, azzerandola il risultato sarà la chiusura dello
              standard error.
       CDPATH Il percorso di ricerca per il comando cd. Questo è un elenco di directory, separate
              da  due  punti, nelle quali la shell cerca le directory di destinazione specificate
              dal comando cd. Un valore di esempio è ".:~:/usr".
       CHILD_MAX
              Imposta il numero di valori dello stato di uscita delle shell figlie da  tenere  in
              memoria.   Bash  non  permette  che  questo  valore scenda al di sotto di un minimo
              imposto da POSIX, e c'è un valore massimo (attualmente 8192)  che  non  può  essere
              superato.  Il valore minimo è dipendente dal sistema.
       COLUMNS
              Usato  dal  comando  composto  select  per  determinare  il  numero  di colonne del
              terminale nella stampa delle  liste  di  selezione.  Automaticamente  impostata  se
              l'opzione   checkwinsize è abilitata o è in una shell interattiva 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).  Ogni  elemento  di  array  contiene  un
              completamento possibile.
       EMACS  Se bash trova questa variabile d'ambiente alla partenza della shell col valore "t",
              presume che la shell sia in esecuzione in un buffer di shell Emacs e disabilita  la
              modifica della riga.
       ENV    È  espansa  ed  eseguita similarmente a BASH_ENV (si veda INVOCAZIONE sopra) quando
              una shell interattiva viene invocata in modalità posix.
       EXECIGNORE
              A colon-separated list of shell patterns (see Pattern Matching)  defining the  list
              of  filenames  to  be  ignored  by  command  search  using  PATH.  Files whose full
              pathnames match one of these patterns are not considered executable files  for  the
              purposes of completion and command execution via PATH lookup.  This does not affect
              the behavior of the [, test, and [[ commands.  Full pathnames in the  command  hash
              table  are  not  subject to EXECIGNORE.  Use this variable to ignore shared library
              files that have the executable bit set, but are not executable files.  The  pattern
              matching honors the setting of the extglob shell option.
       FCEDIT L'editor predefinito per il comando incorporato fc.
       FIGNORE
              Una  lista  di  suffissi,  separati da due punti, da ignorare quando si effettua il
              completamento del nome-file (si veda READLINE più  avanti).  Un  nome-file  il  cui
              suffisso corrisponde a una delle voci in FIGNORE è escluso dalla lista dei nomifile
              individuati. Un valore di esempio è ".o:~" (La quotatura  è  necessaria  quando  si
              assegna un valore a questa variabile, che contiene delle tilde).
       FUNCNEST
              Se  impostato  a  un valore numerico maggiore di 0, definisce un livello massimo di
              nidificazione per una funzione. Invocazioni di funzione  eccedenti  questo  livello
              provocheranno l'interruzione del comando corrente.
       GLOBIGNORE
              Una  lista di modelli, separati da due punti, che definiscono l'insieme dei nomi di
              file che l'espansione del nome di percorso  deve  ignorare.  Se  un  nome  di  file
              individuato  da  un  modello di espansione del percorso corrisponde anche a uno dei
              modelli in GLOBIGNORE viene rimosso dalla lista dei nomi da individuare.
       HISTCONTROL
              Una lista di valori, separati da due punti, che controllano come i comandi  vengono
              salvati nell'elenco della cronologia. Se la lista di valori include ignorespace, le
              righe che iniziano con un carattere di spazio non vengono salvate nell'elenco della
              cronologia.  Un  valore  di ignoredups fa sì che non venga salvata ogni riga uguale
              all'elemento precedente della cronologia. Un valore di ignoreboth è la combinazione
              di ignorespace e ignoredups. Un valore di erasedups fa sì che tutte le righe uguali
              alla riga corrente vengano rimosse dall'elenco della cronologia prima che  la  riga
              venga  salvata.  Qualsiasi valore che non è nella lista di cui sopra è ignorato. Se
              HISTCONTROL non è impostato o non include un valore valido, tutte  le  righe  lette
              dall'analizzatore sintattico della shell sono salvate nell'elenco della cronologia,
              a meno che non sia stato specificato HISTIGNORE. La seconda riga e le successive di
              un  comando  composto  multiriga  non  vengono  controllate,  e  sono aggiunte alla
              cronologia indipendentemente dal valore di HISTCONTROL.
       HISTFILE
              Il nome del file nel quale è salvata la cronologia dei comandi (si veda  CRONOLOGIA
              più  avanti).   Il  valore  predefinito  è  ~/.bash_history.   Se  è  annullato  la
              cronologia dei comandi non è salvata al termine di una shell.
       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, per contenere non più di quel numero di righe rimuovendo  le  voci  più
              vecchie.   Il file della cronologia è inoltre troncato  a  questa  dimensione  dopo
              la scrittura  al  termine  di  una  shell.   Se  il  valore  è  0,  il  file  della
              cronologia  è troncato alla dimensione zero.  Valori non numerici e valori numerici
              minori di zero inibiscono il troncamento.  La shell imposta il  valore  predefinito
              al valore di  HISTSIZE dopo la lettura di un file di avvio.
       HISTIGNORE
              Una  lista  di  modelli  separati  da  due  punti usata per decidere quali righe di
              comando devono essehonorsre 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  precedentedella  cronologia.
              `&'  può essere protetto usando una barra inversa; la barra inversa è rimossa prima
              di eseguire un confronto. La seconda riga e le successive di  un  comando  composto
              multiriga    non   vengono   controllate,   e   sono   aggiunte   alla   cronologia
              indipendentemente dal  valore  di  HISTIGNORE.   Il  modello  di  ricerca  rispetta
              l'impostazione dell'opzione di shell  extglob .
       HISTSIZE
              Il  numero  di  comandi  da tenere in memoria nella cronologia dei comandi (si veda
              HISTORY più avanti).  Se il valore è 0, i comandi non vengono  salvati  nell'elenco
              della  cronologia.   Con  valori numerici minori di zero ogni comando viene salvato
              nell'elenco della cronologia (non ci sono limiti).   La  shell  imposta  il  valore
              predefinito a 500 dopo aver letto i file d'inizializzazione.
       HISTTIMEFORMAT
              Se  questa variabile è impostata e non nulla, il suo valore è usato come stringa di
              formato per strftime(3) per stampare la marcatura  oraria  associata  a  ogni  voce
              della  cronologia  mostrata dal comando incorporato history.  Se questa variabile è
              impostata, data e ora verranno scritte nel file della cronologia in modo da  essere
              disponibili  anche in successive sessioni della shell. Per distinguere la marcatura
              oraria dalle altre righe della cronologia viene usato il carattere di commento.
       HOME   La home directory dell'utente corrente;  l'argomento  predefinito  per  il  comando
              incorporato  cd.  Il  valore  di  questa variabile è anche usata quando si effettua
              l'espansione della tilde.
       HOSTFILE
              Contiene il nome di un file nello stesso formato di  /etc/hosts  che  dovrà  essere
              letto  quando  la  shell  ha  bisogno  di  completare un nome di host. La lista dei
              possibili completamenti di nome di host può essere cambiata mentre la  shell  è  in
              esecuzione;  alla  prossima  occasione in cui si tenta il completamento del nome di
              host dopo che è cambiato il valore, bash aggiunge il contenuto del nuovo file  alla
              lista  esistente. Se HOSTFILE è impostato ma non ha alcun valore, o non contiene il
              nome di un file leggibile, bash tenta di leggere /etc/hosts per ottenere  la  lista
              dei  possibili  completamenti del nome di host. Quando HOSTFILE viene annullato, la
              lista dei nomi di host viene pure annullata.
       IFS    L'Internal  Field  Separator  (separatore  di  campo  interno)  è  usato   per   la
              suddivisione  in  parole dopo l'espansione e per dividere le righe in parole quando
              si   esegue   il   comando   incorporato   read.   Il    valore    predefinito    è
              “<space><tab><newline>”.
       IGNOREEOF
              Controlla  l'azione  della  shell  al  ricevimento  di  un carattere EOF come unico
              contenuto di una riga di input. Se impostato, il valore è il  numero  di  caratteri
              EOF consecutivi da battere come primo carattere su una riga di input prima che bash
              esca. Se la variabile esiste ma non ha un valore numerico, o non ha  alcun  valore,
              il  valore  predefinito  è  10. Se non esiste, EOF indica la fine dell'input per la
              shell.
       INPUTRC
              Il nome-file per il file di avvio di readline che prevale  sul  valore  predefinito
              che è ~/.inputrc (si veda READLINE più avanti).
       INSIDE_EMACS
              If  this  variable  appears  in the environment when the shell starts, bash assumes
              that it is running inside an Emacs shell  buffer  and  may  disable  line  editing,
              depending on the value of TERM.
       LANG   Usata  per  determinare  la categoria di localizzazione per qualsiasi categoria non
              specificatamente indicata da una delle variabili che iniziano con LC_.
       LC_ALL Questa variabile prevale sul valore di LANG e su qualsiasi altra variabile LC_  che
              specifichi una categoria di localizzazione.
       LC_COLLATE
              Questa  variabile  determina l'ordine di collazione usato quando vengono ordinati i
              risultati dell'espansione di nome di percorso,  e  determina  il  comportamento  di
              espressioni  di  intervallo,  classi  di  equivalenza  e  sequenze  di  ordinamento
              all'interno  dell'espansione  di  nome  di  percorso  e  della  corrispondenza  tra
              stringhe.
       LC_CTYPE
              Questa  variabile  determina  l'interpretazione  di caratteri e il comportamento di
              classi di caratteri  all'interno  dell'espansione  di  nome  di  percorso  e  della
              corrispondenza tra stringhe.
       LC_MESSAGES
              Questa  variabile  determina  la  localizzazione  usata  per  tradurre stringhe tra
              virgolette precedute da un $.
       LC_NUMERIC
              Questa  variabile  determina  la  categoria  di   localizzazione   usata   per   la
              formattazione dei numeri.
       LC_TIME
              Questa   variabile   determina   la   categoria  di  localizzazione  usata  per  la
              formattazione di data e ora.
       LINES  Usato dal comando composto select per determinare il numero di linee del  terminale
              nella  stampa  delle  liste  di  selezione.  Automaticamente impostata se l'opzione
              checkwinsize è abilitata o in una shell interattiva al ricevimento  di  un  segnale
              SIGWINCH.
       MAIL   Se  questo  parametro  è  impostato a un nome di file o di directory e la variabile
              MAILPATH non è impostata, bash informa  l'utente  dell'arrivo  di  posta  nel  file
              specificato o nella directory del formato Maildir.
       MAILCHECK
              Specifica  la  frequenza  (in  secondi)  con cui bash controlla la posta. Il valore
              predefinito è 60 secondi. Quando è il momento di controllare la posta, la shell  lo
              fa  prima  di mostrare il prompt primario. Se questa variabile non è impostata, o è
              impostata a un valore che non sia un numero maggiore o  uguale  a  zero,  la  shell
              disabilita il controllo della posta.
       MAILPATH
              Una lista di nomifile 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-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 fpuò essere configurato per fornire un valore predefinito per questa variabile
              non c'è nessun valore predefinito), ma il posizionamento dei file  di  posta  degli
              utenti utilizzato è dipendente dal sistema (per esempio, /var/mail/$USER).
       OPTERR Se  impostato  al  valore  1, bash mostra i messaggi di errore generati dal comando
              incorporato getopts (si veda COMANDI INCORPORATI DELLA SHELL più avanti).  OPTERR è
              inizializzato  ad  1  ogni  volta  che viene invocata la shell o viene eseguito uno
              script di shell.
       PATH   Il percorso di ricerca dei comandi. È un elenco di directory separate da due punti,
              nelle  quali  la shell cerca i comandi (si veda ESECUZIONE DEI COMANDI più avanti).
              Un nome di directory di lunghezza  zero  (nulla)  nel  valore  di  PATH  indica  la
              directory  corrente.  Un nome di directory nullo può apparire come una serie di due
              punti adiacenti, o come due punti all'inizio o alla fine. Il percorso predefinito è
              dipendente  dal  sistema  ed  è impostato dall'amministratore che installa bash. Un
              valore frequente è ``/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:
              /sbin''.
       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.  Quando la shell entra in  modalità posix, imposta questa variabile
              se non fosse già impostata.
       PROMPT_COMMAND
              If this variable is set, and is an array, the value of each set element is executed
              as a command prior to issuing each primary prompt.  If this is set but not an array
              variable, its value is used as a command to execute instead.
       PROMPT_DIRTRIM
              Se impostata a un numero maggiore di zero, il valore è  usato  come  il  numero  di
              componenti  della  directory  finale  da conservare quando si espandono i caratteri
              protetti della stringa di prompt  \w  e  \W  (si  veda  PROMPTING  più  avanti).  I
              caratteri rimossi sono sostituiti da un'ellissi.
       PS0    Il  valore  di questo parametro è espanso (si veda STRINGHE DI PROMPT più avanti) e
              visualizzato dalle shell interattive dopo aver letto un  comando  e  prima  che  il
              comando venga eseguito.
       PS1    Il  valore  di questo parametro è espanso (si veda STRINGHE DI PROMPT più avanti) e
              usato come stringa del prompt primario. Il valore predefinito è“\s-\v\$”.
       PS2    Il valore di questo parametro è espanso allo stesso modo di PS1  ed  è  usato  come
              stringa di prompt secondario. Il valore predefinito è “> ”.
       PS3    Il  valore  di  questo parametro è usato come prompt per il comando select (si veda
              GRAMMATICA DELLA SHELL sopra).
       PS4    Il valore di questo parametro è espanso allo stesso modo di  PS1  ed  il  valore  è
              stampato  prima  di ogni comando che bash mostra durante un trace di esecuzione. Il
              primo carattere  del  valore  espanso  di  PS4  è  replicato  tante  volte,  quanto
              necessario,  per  indicare livelli multipli di indirezione. Il valore predefinito è
              “+”.
       SHELL  Questa variabile si espande al 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.

              a  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\t%3lS'.  Se  il  valore è nullo, non viene mostrata
              alcuna informazione di tempo. Una newline finale è aggiunta quando  la  stringa  di
              formato è visualizzata.
       TMOUT  Se  impostato  a  un valore maggiore di zero, TMOUT è trattato come il tempo limite
              (timeout) predefinito per il comando incorporato read.  Il  comando   select  viene
              terminato  se  non  riceve  input  dopo TMOUT secondi quando l'input proviene da un
              terminale. In una shell interattiva il valore è  interpretato  come  il  numero  di
              secondi  di  attesa per l'input dopo l'emissione del prompt primario.  Bash termina
              dopo aver aspettato per quel numero di secondi se non arriva una riga  completa  di
              input.
       TMPDIR Se  impostato,  bash  usa  il suo valore come nome della directory nella quale bash
              crea file temporanei a uso della shell.
       auto_resume
              Questa variabile controlla il modo con cui la shell interagisce con l'utente e  con
              il  job-control.  Se questa variabile è impostata, dei comandi semplici composti da
              una sola parola senza ridirezioni sono considerati come candidati per la ripresa di
              un  job  in esecuzione che sia stato sospeso.  Non è possibile alcuna ambiguità; se
              vi è più di un job che comincia con la stringa digitata, è scelto il job su cui  si
              è  effettuato  l'accesso  più  recentemente.  Il  nome di un job sospeso, in questo
              contesto, è la riga di comando usata per avviarlo. Se impostato al valore exact, la
              stringa  fornita  deve  essere  esattamente  uguale  al  nome  di  un job fermo; se
              impostato a substring, la stringa fornita deve combaciare con una sottostringa  del
              nome  di  un  job  sospeso.  Il  valore  substring  fornisce  funzionalità analoghe
              all'identificatore del job %? (si veda JOB 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  predefinito  è  `^'.   Il  terzo  carattere,  opzionale, è il
              carattere che indica che il resto della riga è un commento, quando è  trovato  come
              primo  carattere  di  una  parola,  normalmente `#'. Il carattere di commento della
              cronologia fa sì  che  la  sostituzione  della  cronologia  venga  saltata  per  le
              rimanenti  parole  sulla  riga.  Esso  non fa necessariamente sì che l'analizzatore
              della shell tratti il resto della riga come un commento.

   Array
       Bash fornisce variabili array monodimensionali indicizzate e associative.  Ogni  variabile
       può  essere  usata  come  un  array  indicizzato;  il comando incorporato declare dichiara
       esplicitamente un array. Non c'è un limite massimo per  la  dimensione  di  un  array,  né
       alcuna  richiesta  che  gli  elementi  siano indicizzati o assegnati in modo contiguo. Gli
       array  indicizzati  sono  referenziati  usando  numeri  interi  (incluse  le   espressioni
       aritmetiche)  e  cominciano  con  l'indice  zero.  Gli array associativi sono referenziati
       utilizzando stringhe arbitrarie.  Salvo che sia diversamente indicato,  gli  indici  degli
       array indicizzati devono essre interi non negativi.

       Un  array  indicizzato è creato automaticamente se gli è assegnata una qualsiasi variabile
       usando la sintassi nome[deponente]=valore. Il deponente  (indice  dell'array)  è  trattato
       come un'espressione aritmetica che deve risultare un numero. Per dichiarare esplicitamente
       un array indicizzato, usare declare -a nome (si veda COMANDI INCORPORATI DELLA  SHELL  più
       avanti). È anche accettato declare -a nome[deponente]; il deponente viene ignorato.

       Array associativi sono creati usando declare -A nome.

       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 può essere della  forma  [deponente]=stringa.
       Le  assegnazioni  di array indicizzati non richiedono nient'altro che stringa. Ogni valore
       nella lista è espanso usando tutte le espansioni  della  shell  descritte  più  avanti  in
       ESPANSIONE.   Quando  si  fanno  assegnamenti  ad array indicizzati, se vengono fornite le
       parentesi opzionali e il deponente, l'elemento viene assegnato a quell'indice;  altrimenti
       l'indice  dell'elemento  assegnato  è  l'ultimo  indice  già  utilizzato aumentato di uno.
       L'indicizzazione parte da zero.

       When assigning to an associative array, the words in a compound assignment may  be  either
       assignment  statements,  for  which  the subscript is required, or a list of words that is
       interpreted as a sequence of alternating keys and values: name=( key1 value1  key2  value2
       ...).   These  are  treated  identically  to name=( [key1]=value1 [key2]=value2 ...).  The
       first word in the list determines how the remaining words are interpreted; all assignments
       in  a  list  must  be  of  the same type.  When using key/value pairs, the keys may not be
       missing or empty; a final missing value is treated like the empty string.

       Questa sintassi è accettata anche dal comando incorporato declare. Elementi singoli di  un
       array  possono  essere  assegnati  con  la  sintassi nome[deponente]=valore introdotta più
       sopra.  Quando si fanno assegnamenti a un array indicizzato, se nome è indicizzato  da  un
       numero  negativo,  quel  numero  è  interpretato come relativo all' indice massimo di nome
       aumentato  di  uno,  perciò  indici  negativi  si  conteggiano   dalla   fine   dell'array
       all'indietro, e un indice -1 corrisponde all'ultimmo elemento.

       The  +=  operator  will  append  to  an  array  variable when assigning using the compound
       assignment syntax; see PARAMETERS above.

       Qualsiasi elemento  di  un  array  può  essere  referenziato  con  ${nome[deponente]}.  Le
       parentesi  sono richieste per evitare conflitti con l'espansione di percorso. Se deponente
       è @ o *, la parola espande a tutti gli elementi di  nome.  Questi  deponenti  differiscono
       solo  quando  la  parola  appare  inclusa  fra  virgolette.  Se  la  parola  è quotata con
       virgolette, ${nome[*]} espande a una singola parola col valore di ogni elemento dell'array
       separato  dal  primo  carattere  della  variabile  speciale IFS, e ${nome[@]} espande ogni
       elemento di nome come una parola separata. Quando non c'è l'elemento di array,  ${nome[@]}
       è  espanso  alla stringa nulla. Se l'espansione quotata con virgolette si trova dentro una
       parola, l'espansione del primo parametro è legato  con  la  parte  iniziale  della  parola
       originale,  e  l'espansione dell'ultimo parametro è legato con l'ultima parte della parola
       originale. Questo è analogo all'espansione dei parametri speciali * e @ (si veda Parametri
       speciali  sopra).  ${#nome[deponente]}  espande  alla  lunghezza di ${nome[deponente]}. Se
       deponente è * o @, l'espansione è il numero di elementi dell'array.  Se il deponente usato
       per referenziare un elemento di un array indicizzato risulta, dopo l'espansione, un numero
       minore di zero, è interpretato come relativo all' indice massimo dell'array  aumentato  di
       uno, perciò indici negativi si conteggiano dalla fine dell'array all'indietro, e un indice
       -1 corrisponde all'ultimo elemento.

       Referenziare una variabile array senza specificare un deponente  equivale  a  referenziare
       l'array  con  un  deponente  pari  a  zero.   Ogni  riferimento  a una variabile usando un
       deponente valido è consentito, e bash creerà un array se necessario

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

       È  possibile  ottenere  sia  le  chiavi  (indici)  che i valori di un array. ${!nome[@]} e
       ${!nome[*]} espandono agli indici assegnati nella  variabile  array  nome.  Quando  è  fra
       virgolette  il  trattamento è simile all'espansione dei parametri speciali @ e * posti tra
       virgolette.

       The unset builtin is used to destroy arrays.  unset  name[subscript]  destroys  the  array
       element  at index subscript, for both indexed and associative arrays.  Negative subscripts
       to indexed arrays are interpreted as described above.  Unsetting the last  element  of  an
       array  variable  does not unset the variable.  unset name, where name is an array, removes
       the entire array.  unset name[subscript], where subscript is * or @,  behaves  differently
       depending  on  whether name is an indexed or associative array.  If name is an associative
       array, this unsets the element with subscript * or @.  If name is an indexed array,  unset
       removes all of the elements but does not remove the array itself.

       When  using  a  variable  name  with a subscript as an argument to a command, such as with
       unset, without using the word expansion syntax described above, the argument is subject to
       pathname expansion.  If pathname expansion is not desired, the argument should be quoted.

       Ciascuno  dei  comandi  incorporati  declare,  local  e readonly accetta un'opzione -a per
       specificare un array indicizzato e un'opzione -A per specificare un array associativo.  Se
       vengono  fornite  entrambe  le  opzioni,  -A ha la precedenza. Il comando incorporato read
       accetta un'opzione -a per assegnare a un array una lista di parole  lette  dallo  standard
       input.  I  comandi  incorporati  set  e  declare mostrano i valori di array in modo che da
       essere riutilizzabili come assegnamenti.

ESPANSIONE

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

       L'ordine  di  espansione  è:  espansione  delle  parentesi graffe, espansione della tilde,
       espansione di parametro e di variabile, espansione 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.   Questa  è  effettuata  contemporaneamente  come  espansione  della  tilde,  di
       parametro, di variabile e aritmetica, e come sostituzione di comando.

       Una  volta  effettuale  queste  espansioni, i caratteri di quotatura presenti nella parola
       originale vengono rimossi, a meno che siano essi stessi quotati (rimozione  dei  segni  di
       quotatura)

       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 sono le
       espansioni di “$@” e "${nome[@]}", e in molti casi $* and ${name[*]} come  spiegato  sopra
       (si vedi 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'.

       A sequence expression takes the form {x..y[..incr]}, where x and y are either integers  or
       single  letters,  and  incr,  an  optional  increment,  is  an integer.  When integers are
       supplied, the expression expands to each number between  x  and  y,  inclusive.   Supplied
       integers  may be prefixed with 0 to force each term to have the same width.  When either x
       or y begins with a zero, the shell attempts to force all generated terms  to  contain  the
       same  number  of  digits,  zero-padding  where  necessary.  When letters are supplied, the
       expression expands to each character lexicographically between x and y,  inclusive,  using
       the  default  C  locale.   Note  that  both  x  and y must be of the same type (integer or
       letter).  When the increment is supplied, it is used as the difference between each  term.
       The default increment is 1 or -1 as appropriate.

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

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

       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.

       Bash  also  performs  tilde  expansion  on  words  satisfying  the  conditions of variable
       assignments (as described above under PARAMETERS)  when they appear as arguments to simple
       commands.   Bash  does not do this, except for the declaration commands listed above, when
       in posix mode.

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

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

       ${parametro}
              Il  valore  di  parametro  è  sostituito. Le parentesi graffe sono richieste quando
              parametro è un parametro posizionale con più di una cifra,  o  quando  parametro  è
              seguito  da  un carattere che non deve essere interpretato come parte del suo nome.
              Il parametro  è un parametro  di  shell  come  descritto  sopra  (PARAMETRI)  o  un
              riferimento a un array (Array).

       Se  il  primo  carattere  di  parametro  è  un punto esclamativo (!), e parametro non è un
       nameref,  introduce un livello di indirezione. Bash usa il valore  formato  espandento  il
       resto di parametro come il nuovo parametro; questo è poi espanso e quel valore è usato nel
       resto dell'espansione, piuttosto che  l'espansione  del  parametro  originario.  Questa  è
       conosciuta  come  espansione  indiretta.  Il valore è soggetto all'espansione della tilde,
       espansione di parametro, sostituzione di comando, ed espansione aritmetica. Se parametro è
       un  nameref,  questo  espande  al  nome del parametro referenziato da  parametro invece di
       effettuare l'espanzione indiretta completa. 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 sottostringa, usando le forme documentate
       più avanti (p.es., :-), Bash controlla  se  un  parametro  non  è  impostato  o  è  nullo.
       L'omissione dei due punti provoca il solo controllo di un parametro non impostato.

       ${parametro:-parola}
              Usa  i  valori  predefiniti.  Se  parametro non è impostato o è nullo, è sostituita
              l'espansione di parola. Altrimenti, il valore di parametro è sostituito.
       ${parametro:=parola}
              Assegna i valori predefiniti. Se parametro non è impostato o è nullo,  l'espansione
              di  parola  è  assegnata a parametro. Il valore di parametro è quindi sostituito. I
              parametri posizionali e i parametri speciali non possono essere assegnati in questo
              modo.
       ${parametro:?parola}
                una segnalazione di errore se è nullo o è stato annullato. Se parametro è nullo
              o è stato annullato, l'espansione di parola (o un  messaggio  di  segnalazione,  se
              parola  non  è  presente)  viene  scritta sullo standard error e la shell, se non è
              interattiva, termina. Altrimenti, è sostituito il valore di parametro.
       ${parametro:+parola}
              Se parametro è nullo o è stato annullato, non è  sostituito  niente,  altrimenti  è
              sostituita l'espansione di parola.
       ${parametro:scostamento}
       ${parametro:scostamento:lunghezza}
              Substring  Expansion.  Expands to up to length characters of the value of parameter
              starting at the character specified by offset.  If parameter is @ or *, an  indexed
              array  subscripted  by  @ or *, or an associative array name, the results differ as
              described below.  If length is omitted, expands to the substring of  the  value  of
              parameter starting at the character specified by offset and extending to the end of
              the value.  length and offset are arithmetic expressions (see ARITHMETIC EVALUATION
              below).

              Se  scostamento  è un numero minore di zero, il valore viene usato come scostamento
              nei caratteri dalla fine del valore di parametro.  Se lunghezza è un numero  minore
              di  zero, viene interpretato come uno scostamento in caratteri dalla finedel valore
              di  parametro  piuttosto  che  come  un  numero  di  caratteri,  e  l'espansione  è
              rappresentata  dai  caratteri fra lo scostamento e quel risultato.  Si noti che uno
              scostamento negativo dev'essere separato dai due punti da  almeno  uno  spazio  per
              evitare che venga confuso con l'espansione di :-.

              If  parameter  is  @  or *, the result is length positional parameters beginning at
              offset.  A negative offset is taken relative  to  one  greater  than  the  greatest
              positional  parameter,  so  an  offset  of  -1  evaluates  to  the  last positional
              parameter.  It is an expansion error if length evaluates  to  a  number  less  than
              zero.

              Se  parametro è un nome di array indicizzato con deponente @ o *, il risultato è un
              numero   di   elementi   dell'array    pari    a    lunghezza    a    partire    da
              ${parametro[scostamento]}.   Uno  scostamento  negativo  è  inteso come relativo al
              massimo indice dell'array specificato aumentato di uno. È un errore  di  espansione
              se lunghezza è un numero minore di zero.

              L'espansione  di  substringa  applicata  a  un  array associativo produce risultati
              indefiniti.

              L'indicizzazione della sottostringa è a base zero a meno che non  vengano  usati  i
              parametri  posizionali, nel qual caso l'indicizzazione parte da 1 come impostazione
              predefinita.  Se scostamento è 0, e vengono usati  i  parametri  posizionali,  alla
              lista è aggiunto il prefisso $0.

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

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

       ${#parametro}
              lunghezza  parametro}  È  sostituita  la  lunghezza  in  caratteri  del  valore  di
              parametro.  Se parametro è * o @, il valore sostituito è  il  numero  di  parametri
              posizionali.   Se  parametro  è  un nome di array contrassegnato da * o @ il valore
              sostituito è il numero di elementi nell'array. Se parametro  è  un  nome  di  array
              indicizzato  con  deponente  negativo,  quel numero è interpretato come relativo al
              massimo   indice  di  parametro   aumentato  di  uno,  perciò  indici  negativi  si
              conteggiano  dalla  fine  dell'array  all'indietro,  e  un  indice  -1  corrisponde
              all'ultimo elemento.

       ${parametro#parola}
       ${parametro##parola}
              Rimozione del suffisso corrispondente al modello. La parola è espansa per  produrre
              un  modello  proprio  come  nell'espansione  di  percorso, e confrontata col valore
              espanso di parametro usando le regole descritte più avanti in Modelli  di  ricerca.
              Se  il  modello corrisponde a una parte finale del  valore espanso di parametro, il
              risultato dell'espansione è il valore espanso di parametro con  il  più  corto  dei
              modelli  corrispondenti  cancellato  (nel  caso di “#” ) o il più lungo dei modelli
              corrispondenti cancellato (nel caso di “##”). Se parametro è @ o *, l'operazione di
              rimozione   del   modello  è  applicata  a  ognuno  dei  parametri  posizionali,  e
              l'espansione è la  lista  risultante.  Se  parametro  è  una  variabile  array  con
              deponente  @  o *, l'operazione di rimozione del modello è applicata a ognuno degli
              elementi dell'array, e l'espansione è la lista risultante.

       ${parametro%parola}
       ${parametro%%parola}
              Rimozione del suffisso corrispondente al modello. La parola è espansa per  produrre
              un  modello  proprio  come  nell'espansione  di percorso,  e confrontata col valore
              espanso di parametro usando le regole descritte più avanti in Modelli  di  ricerca.
              Se  il  modello  corrisponde a una parte finale del valore espanso di parametro, il
              risultato dell'espansione è il valore espanso di parametro con  il  più  corto  dei
              modelli  corrispondenti  cancellato  (nel  caso di “%” ) o il più lungo dei modelli
              corrispondenti cancellato (nel caso di “%%”).  Se parametro è @ o  *,  l'operazione
              di  rimozione  del  modello  è  applicata  a  ognuno  dei  parametri posizionali, e
              l'espansione è la  lista  risultante.  Se  parametro  è  una  variabile  array  con
              deponente  @  o *, l'operazione di rimozione del modello è applicata a ognuno degli
              elementi dell'array, e l'espansione è la lista risultante.

       ${parameter/modello/stringa}
       ${parameter//pattern/string}
       ${parameter/#pattern/string}
       ${parameter/%pattern/string}
              Pattern substitution.  The pattern is expanded to produce  a  pattern  just  as  in
              pathname expansion.  Parameter is expanded and the longest match of pattern against
              its value is replaced with string.  string undergoes tilde expansion, parameter and
              variable  expansion,  arithmetic  expansion,  command and process substitution, and
              quote removal.  The match is performed using  the  rules  described  under  Pattern
              Matching  below.   In  the  first form above, only the first match is replaced.  If
              there are two slashes separating parameter and pattern (the second form above), all
              matches  of  pattern  are  replaced  with string.  If pattern is preceded by # (the
              third form above), it must  match  at  the  beginning  of  the  expanded  value  of
              parameter.   If  pattern is preceded by % (the fourth form above), it must match at
              the end of the expanded value of parameter.  If the expansion of  string  is  null,
              matches  of pattern are deleted.  If string is null, matches of pattern are deleted
              and the / following pattern may be omitted.

              If the patsub_replacement  shell  option  is  enabled  using  shopt,  any  unquoted
              instances of & in string are replaced with the matching portion of pattern.

              Quoting  any  part  of  string  inhibits replacement in the expansion of the quoted
              portion, including replacement strings stored in shell variables.   Backslash  will
              escape  & in string; the backslash is removed in order to permit a literal & in the
              replacement string.  Backslash can also be used to escape a backslash;  \\  results
              in  a  literal  backslash  in the replacement.  Users should take care if string is
              double-quoted  to  avoid  unwanted   interactions   between   the   backslash   and
              double-quoting,  since backslash has special meaning within double quotes.  Pattern
              substitution performs the check  for  unquoted  &  after  expanding  string;  shell
              programmers  should  quote  any occurrences of & they want to be taken literally in
              the replacement and ensure any  instances  of  &  they  want  to  be  replaced  are
              unquoted.

              If  the  nocasematch shell option is enabled, the match is performed without regard
              to the case of alphabetic characters.  If parameter is @  or  *,  the  substitution
              operation is applied to each positional parameter in turn, and the expansion is the
              resultant list.  If parameter is an array variable subscripted with  @  or  *,  the
              substitution  operation  is  applied  to  each member of the array in turn, and the
              expansion is the resultant list.

       ${parametro^modello}
       ${parametro^^modello}
       ${parametro,modello}
       ${parametro,,modello}
              Modifica minuscolo/maiuscolo. Questa espansione modifica in parametro  i  caratteri
              alfabetici  da  minuscolo  a  maiuscolo  e  viceversa. Il modello viene espanso per
              produrre un modello, proprio come nell'espansione del nome di  percorso.    Ciascun
              carattere  nel  valore  espanso  di   parametro viene confrontato con modello e, se
              corrisponde al modello, le minuscole/maiuscole vengono  convertite.    Il   modello
              potrebbe   non  cercare  corrispondenze  con   più  di un carattere.  L'operatore ^
              converte le lettere minuscole che  corrispondono a modello  in  lettere  maiuscole;
              l'operatore  ,  converte  le  lettere  maiuscole  trovate  in lettere minuscole. Le
              espansioni ^^ e ,,  convertono  ogni  carattere  trovato  nel  valore  espanso;  le
              espansioni  ^  e , trovano e convertono solo il primo carattere nel valore espanso.
              Se modello è omesso, è trattato come un ?, che  individua  tutti  i  caratteri.  Se
              parametro  è  @  o *, l'operazione di conversione minuscole/maiuscole è applicata a
              tutti i parametri posizionali successivi, e l'espansione è la lista risultante.  Se
              parametro  è una variabile array indicizzata con @ o *, l'operazione di conversione
              minuscole/maiuscole è  applicata  a  tutti  i  successivi  elementi  dell'array,  e
              l'espansione è la lista risultante.

       ${parametro@operatore}
              Trasformazione  di  parametro.  L'espansione  è  o una trasformazione del valore di
              parametro  o  un'informazione  su  parametro  stesso,  a  seconda  del  valore   di
              operatore.  Ogni operatore è una sola lettera:

              U      L'espansione  è  una  stringa  che  è il valore di  parametro  coi caratteri
                     alfabetici minuscoli convertiti in maiuscolo.
              u      L'espansione è una stringa che è il valore di  parametro  co primo carattere
                     convertito in maiuscolo, se è alfabetico.
              L      L'espansione  è  una  stringa  che  è il valore di  parametro  coi caratteri
                     alfabetici maiuscoli convertiti in minuscolo.
              Q      L'espansione è una stringa che è il valore  di   parametro   quotato  in  un
                     formato riutilizzabile come input.
              E      The  expansion  is  a  string  that is the value of parameter with backslash
                     escape sequences expanded as with the $'...' quoting mechanism.
              P      L'espansione è una stringa che è il risutato dell'espansione del  valore  di
                     parametro come se fosse una stringa di prompt (si veda più avanti STRINGHE D
                     PROMPT).
              A      L'espansione è una stringa nella forma di istruzione di  assegnamento  o  di
                     comando  declare  che, se valutato, ricreerà  parametro coi suoi attributi e
                     col suo valore.
              K      Produces a possibly-quoted version of the value of parameter, except that it
                     prints  the values of indexed and associative arrays as a sequence of quoted
                     key-value pairs (see Arrays above).
              a      L'espansione è una stringa consistente di valori di flag  che  rappresentano
                     attirbuti di parametro.
              k      Like  the  K  transformation, but expands the keys and values of indexed and
                     associative arrays to separate words after word splitting.

              Se parametro è @ o *, l'operazione è applicata a ognuno dei parametri  posizionali,
              e  l'espansione  è  la  lista  risultante.   Se parametro è una variabile array con
              deponente @ o *, l'operazione è applicata a ognuno  degli  elementi  dell'array,  e
              l'espansione è la lista risultante.

              Il   risultato   dell'espansione   è    soggetto  alla  suddivisione  in  parole  e
              all'espansione di percorso come descritto più avanti..

   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 in un ambiente di subshell e rimpiazzando
       la sostituzione di comando con lo standard output del comando,  con  ogni  newline  finale
       cancellato.  I newline intermedi non vengono cancellati, ma possono essere rimossi durante
       la suddivisione in parole. La sostituzione di comando $(cat file)  può  essere  sostituita
       dall'equivalente ma più veloce $(< file).

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

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

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

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

              $((espressione))

       Il  vecchio comando  $[expression]  è deprecato e verrà rimosso nelle prossime versioni di
       bash.

       The expression undergoes the same expansions as if  it  were  within  double  quotes,  but
       double  quote  characters  in  expression  are not treated specially and are removed.  All
       tokens in the expression undergo parameter and variable expansion,  command  substitution,
       and  quote  removal.   The result is treated as the arithmetic expression to be evaluated.
       Arithmetic expansions may be nested.

       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 consente di far riferimento a  un  input  o  a  un  output  di
       processo  usando  un  nome-file.  Essa prende la forma di <(lista) o >(lista). La lista di
       processi è eseguita in modalità asincrona,  e  il  suo  input  o  output  appare  come  un
       nome-file.  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. La sostituzione di processo è  supportata  su
       sistemi  che  supportano   le  named pipe (FIFO) o il metodo /dev/fd per denominare i file
       aperti.

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

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

       La shell tratta ogni carattere di IFS come  un  delimitatore,  e  suddivide  in  parole  i
       risultati  delle  altre  espansioni  usando  uno  di questi caratteri come delimitatori di
       campo,   Se  il  valore  di  IFS  non  è  impostato  o  il  suo   valore   è   esattamente
       <space><tab><newline>,  il  valore  predefinito,  sequenze  di  <space>, <tab> e <newline>
       all'inizio e alla fine dei risultati  delle  precedenti  espansioni  vengono  ignorate,  e
       qualsiasi  sequenza  di  caratteri  IFS, che non siano all'inizio o alla fine, servono per
       delimitare le parole. Se IFS ha un valore diverso da quello predefinito,  allora  sequenze
       di  caratteri  di  spaziatura  space  e tab e newline 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 ("" o '') sono conservati e passati ai comandi come stringa
       vuota.   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 ed è conservato e passato a un comando come
       stringa vuota.  Quando un argomento nullo quotato appare come parte di una parola  la  cui
       espansione  è non-nulla, l'argomento nullo viene rimosso.  Cioè, la parola -d'' diventa -d
       dopo la suddiviisone della parola e la rimozione dell'argomento nullo.

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

   Espansione di percorso
       After word splitting, unless the -f option has been set, bash  scans  each  word  for  the
       characters  *,  ?, and [.  If one of these characters appears, and is not quoted, then the
       word is regarded as a  pattern,  and  replaced  with  an  alphabetically  sorted  list  of
       filenames matching the pattern (see Pattern Matching below).  If no matching filenames are
       found, and the shell option nullglob is not enabled, the word is left unchanged.   If  the
       nullglob  option  is  set, and no matches are found, the word is removed.  If the failglob
       shell option is set, and no matches are found, an error message is printed and the command
       is  not  executed.   If  the  shell  option  nocaseglob is enabled, the match is performed
       without regard to  the  case  of  alphabetic  characters.   Note  that  when  using  range
       expressions  like  [a-z] (see below), letters of the other case may be included, depending
       on the setting of LC_COLLATE. When a pattern is used for pathname expansion, the character
       “.”  at  the  start of a name or immediately following a slash must be matched explicitly,
       unless the shell option dotglob is set.  In order to match the filenames “.” and “..”, the
       pattern  must  begin  with  “.”  (for  example,  “.?”),  even  if  dotglob is set.  If the
       globskipdots shell option is enabled, the filenames “.” and “..” are never  matched,  even
       if  the pattern begins with a “.”.  When not matching pathnames, the “.”  character is not
       treated specially.  When matching a pathname, the slash character must always  be  matched
       explicitly  by a slash in the pattern, but in other matching contexts it can be matched by
       a  special  pattern  character  as  described  below  under  Pattern  Matching.   See  the
       description  of  shopt  below  under  SHELL  BUILTIN  COMMANDS  for  a  description of the
       nocaseglob, nullglob, globskipdots, failglob, and dotglob shell options.

       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. Se è impostata l'opzione nocaseglob , il confronto
       coi modelli in GLOBIGNORE è effettuata senza distinzione  tra minuscole  e  maiuscole.   I
       nomifile  “.”  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 nomifile che
       iniziano con un “.”. Per ottenere il  comportamento  (usato  in  precedenti  versioni)  di
       ignorare  i  nomifile  che  iniziano  con “.”, si deve fare un modello “.*” in GLOBIGNORE.
       L'opzione dotglob è disabilitata quando GLOBIGNORE viene annullato. Il modello di  ricerca
       rispetta l'impostazione dell'opzione di shell extglob.

       Modelli di ricerca / espressioni regolari

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

       I caratteri speciali nelle espressioni regolari hanno i seguenti significati:

              *      Corrisponde  a  qualsiasi  stringa,  inclusa  la  stringa  nulla.  Quando  è
                     abilitata l'opzione di shell globstar, e in un contesto  di  espansione  del
                     nome di percorso viene usato *, due * adiacenti usati come unico criterio di
                     ricerca troveranno tutti i file e zero o più directory e sottodirectory.  Se
                     seguito da un /, due * adiacenti troveranno solo directory e sottodirectory.
              ?      Corrisponde a qualsiasi carattere singolo.
              [...]  Matches  any one of the enclosed characters.  A pair of characters separated
                     by a hyphen denotes a range expression; any  character  that  falls  between
                     those  two  characters,  inclusive,  using  the  current  locale's collating
                     sequence and character set, is matched.  If the  first  character  following
                     the [ is a ! or a ^ then any character not enclosed is matched.  The sorting
                     order of characters in range expressions, and the characters included in the
                     range, are determined by the current locale and the values of the LC_COLLATE
                     or LC_ALL shell variables, if set.  To obtain the traditional interpretation
                     of  range expressions, where [a-d] is equivalent to [abcd], set value of the
                     LC_ALL shell variable to C, or enable the globasciiranges shell option.  A -
                     may be matched by including it as the first or last character in the set.  A
                     ] may be matched by including it as the first character in the set.

                     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.

       If the extglob shell option is enabled using  the  shopt  builtin,  the  shell  recognizes
       several extended pattern matching operators.  In the following description, a pattern-list
       is a list of one or more patterns separated by a |.   Composite  patterns  may  be  formed
       using one or more of the following sub-patterns:

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

       Theextglob  option  changes the behavior of the parser, since the parentheses are normally
       treated as operators with syntactic meaning.  To ensure that  extended  matching  patterns
       are  parsed  correctly,  make  sure  that  extglob  is  enabled  before parsing constructs
       containing the patterns, including shell functions and command substitutions.

       When matching filenames, the dotglob shell option determines the set of filenames that are
       tested:  when  dotglob  is enabled, the set of filenames includes all files beginning with
       “.”, but “.” and “..” must be matched by a pattern or sub-pattern that begins with a  dot;
       when  it is disabled, the set does not include any filenames beginning with “.” unless the
       pattern or sub-pattern begins with a “.”.  As above, “.” only has a special  meaning  when
       matching filenames.

       Complicated  extended  pattern  matching against long strings is slow, especially when the
       patterns contain alternations and the strings contain multiple  matches.   Using  separate
       matches  against  shorter  strings,  or  using  arrays of strings instead of a single long
       string, may be faster.

   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

       Before  a  command  is  executed,  its  input and output may be redirected using a special
       notation interpreted by the shell.   Redirection  allows  commands'  file  handles  to  be
       duplicated, opened, closed, made to refer to different files, and can change the files the
       command reads from and writes to.  Redirection may also be used to modify file handles  in
       the  current shell execution environment.  The following redirection operators may precede
       or appear anywhere within a simple command or may  follow  a  command.   Redirections  are
       processed in the order they appear, from left to right.

       Each  redirection that may be preceded by a file descriptor number may instead be preceded
       by a word of the form {varname}.  In this case, for each redirection operator  except  >&-
       and  <&-, the shell will allocate a file descriptor greater than or equal to 10 and assign
       it to varname.  If >&- or <&- is preceded by {varname}, the value of varname  defines  the
       file  descriptor  to close.  If {varname} is supplied, the redirection persists beyond the
       scope of the command, allowing the  shell  programmer  to  manage  the  file  descriptor's
       lifetime manually.  The varredir_close shell option manages this behavior.

       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 e di variabile, sostituzione di  comando,  espansione
       aritmetica,  rimozione  dei caratteri di quotatura, espansione dei percorsi e suddivisione
       in parole. Se si espande a più di una parola bash dà una segnalazione di errore.

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

              ls > dirlist 2>&1

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

              ls 2>&1 > dirlist

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

       Bash   manipola  parecchi  nomi-file  specialmente  quando sono usati in ridirezioni, come
       descritto nella tavola seguente.  Se il sistema operativo nel quale Bash è  in  esecuzione
       fornisce  questi  file speciali, bash userà quelli; altrimenti li emulerà internamente col
       comportamento descritto più avanti.

              /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
                     ilsocket TCP 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 il
                     socket UDP 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.

       Si noti che il comando incorporato e exec  può fare ridirezioni che  hanno  effetto  nella
       shell corrente.

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

       Il formato generico per ridirigere l'input è:

              [n]<parola

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

       Il formato generico per ridirigere l'output è:

              [n]>parola

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

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

       Il formato generico per accodare l'output è:

              [n]>>parola

   Ridirezione di standard output e standard error
       Con  questo  costrutto,  sia  l'uscita  dello  standard output (descrittore di file 1) che
       quella dello standard error (descrittore di file 2) sono ridirette sul file  il  cui  nome
       risulta dall'espansione di parola.

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

              &>parola
       e
              >&parola

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

              >parola 2>&1

       Usando  la seconda forma, parola potrebbe non espandersi a un numero o a -.  Se capita, si
       applicano altri operatori di ridirezione (vedi Duplicazione dei descrittori  di  file  più
       avanti) per ragioni di compatibilità.

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

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

              &>>parola

       Questo è semanticamente equivalente a

              >>parola 2>&1

       (si veda Duplicazione dei descrittori di file più avanti).

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

       Il formato degli here-document è il seguente:

              [n]<<[-]word
                      here-document
              delimitatore

       Nessuna espansione di parametro  e  di  variabile,  sostituzione  di  comando,  espansione
       aritmetica  o  espansione  di percorso è effettuata su parola. Se una  qualsiasi parte  di
       parola è quotata, 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, la sequenza \<newline> è ignorata, e \
       deve essere usata per quotare i caratteri \, $ e `.

       e l'operatore di ridirezione è <<-, tutti i caratteri tab a  inizio  riga  sono  eliminati
       dalle  righe  in  inpute  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 è:

              [n]<<<parola

       La parola è sottoposta a espansione della tilde, espansione di parametro e  di  variabile,
       sostituzione  di  comando,  espansione  aritmetica e rimozione dei caratteri di quotatura.
       L'espanisone di percorso e la suddivisione in parole non vengono effettuate.  Il risultato
       è dato come una stringa singola, con un newline finale,  al comando sul suo standard input
       (o sul descrittore di file n se viene specificato n.

   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.
       Se parola risulta essere, dopo l'espansione, -,  il  descrittore  di  file  file  n  viene
       chiuso.Come  caso speciale, se n è omesso, e parola non si espande in una o più cifre o in
       -, 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.

       There is no mechanism for using arguments in  the  replacement  text.   If  arguments  are
       needed, use a shell function (see FUNCTIONS below).

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

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

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

FUNZIONI

       Una  funzione  di  shell,  definita  come  descritto  prima  in  GRAMMATICA  DELLA  SHELL,
       immagazzina una serie di comandi per una futura esecuzione. Quando il nome di una funzione
       di shell è usato come un nome di comando semplice, la lista di comandi associati con  quel
       nome  di  funzione  viene  eseguita.  Le  funzioni  sono eseguite nel contesto della shell
       corrente; nessun nuovo processo è creato per interpretarle (a differenza di quanto avviene
       eseguendo uno script di shell). Quando una funzione è eseguita, gli argomenti passati alla
       funzione costituiscono  i  parametri  posizionali  della  funzione  stessa.  Il  parametro
       speciale  # viene aggiornato per riflettere il cambiamento. Il parametro speciale 0 rimane
       inalterato. Il primo elemento della variabile FUNCNAME è impostato al nome della  funzione
       durante l'esecuzione della funzione.

       Tutti  gli  altri  aspetti  dell'ambiente  di esecuzione della shell sono identici tra una
       funzione e il suo chiamante con queste eccezioni: la gestione dei segnali DEBUG  e  RETURN
       (si veda la descrizione del comando incorporato trap sotto COMANDI INCORPORATI DELLA SHELL
       più avanti), i quali  non  sono  ereditati  a  meno  che  alla  funzione  sia  stato  dato
       l'attributo  trace  (si  veda la descrizione del comando incorporato declare più avanti) o
       l'opzione di shell -o functrace sia stata abilitata per mezzo del comando incorporato  set
       (nel  qual  caso  tutte le funzioni ereditano la gestione dei segnali DEBUG e RETURN) e la
       gestione del segnale ERR non viene ereditata a meno che l'opzione di shell -o errtrace sia
       stata abilitata.

       Variables  local  to  the  function  may be declared with the local builtin command (local
       variables).  Ordinarily, variables and their values are shared between  the  function  and
       its  caller.   If a variable is declared local, the variable's visible scope is restricted
       to that function and its children (including the functions it calls).

       In the following description, the  current  scope  is  a  currently-  executing  function.
       Previous  scopes  consist of that function's caller and so on, back to the "global" scope,
       where the shell is not executing any shell function.  Consequently, a  local  variable  at
       the  current  scope  is  a  variable  declared  using the local or declare builtins in the
       function that is currently executing.

       Local variables "shadow" variables with the same name declared at  previous  scopes.   For
       instance,  a  local  variable  declared  in a function hides a global variable of the same
       name: references and assignments refer to the local variable, leaving the global  variable
       unmodified.  When the function returns, the global variable is once again visible.

       The  shell uses dynamic scoping to control a variable's visibility within functions.  With
       dynamic scoping, visible variables and their values  are  a  result  of  the  sequence  of
       function  calls  that  caused  execution  to  reach  the current function.  The value of a
       variable that a function sees depends on its value within its caller, if any, whether that
       caller  is  the  "global"  scope or another shell function.  This is also the value that a
       local variable declaration "shadows", and the value that is  restored  when  the  function
       returns.

       Per  esempio, se una variabile locale var è dichiarata come locale in una funzione  func1,
       e  func1 chiama un'altra funzione  func2, i  riferimenti   a  var  fatti  dall'interno  di
       func2  si  risolveranno  nella  variabile  locale  definita  in func1, oscurando qualsiasi
       variabile globale denominata var.

       The unset builtin also acts using the same dynamic scope: if a variable is  local  to  the
       current  scope,  unset will unset it; otherwise the unset will refer to the variable found
       in any calling scope as described above.  If a variable at  the  current  local  scope  is
       unset,  it  will  remain so (appearing as unset)  until it is reset in that scope or until
       the function returns.  Once the function returns,  any  instance  of  the  variable  at  a
       previous  scope will become visible.  If the unset acts on a variable at a previous scope,
       any instance of a variable with that name that had been shadowed will become visible  (see
       below how the localvar_unset shell option changes this behavior).

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

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

       Function names and definitions may be listed with the -f option to the declare or  typeset
       builtin  commands.   The -F option to declare or typeset will list the function names only
       (and optionally the source file and line number, if the extdebug shell option is enabled).
       Functions  may  be  exported so that child shell processes (those created when executing a
       separate shell invocation)  automatically have them defined with  the  -f  option  to  the
       export  builtin.   A  function  definition may be deleted using the -f option to the unset
       builtin.

       Le funzioni possono essere ricorsive. La variabile FUNCNEST può essere usata per  limitare
       la  profondità  dello  stack  della  chiamata  di  funzione  e  restringere  il  numero di
       invocazioni della funzione. Come impostazione  predefinita,  nessun  limite  è  posto  sul
       numero di chiamate ricorsive.

VALUTAZIONE ARITMETICA

       La shell permette di calcolare espressioni aritmetiche, sotto certe circostanze (si veda i
       comandi incorporati let e declare,  il comando composto (( 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
       - +    meno e più unari
       ++id --id
              pre-incremento e pre-decremento di una variabile
       ! ~    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
       espr?espr:espr
              operatore condizionale
       = *= /= %= += -= <<= >>= &= ^= |=
              assegnamento
       espr1 , espr2
              virgola

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

       Le costanti intere seguono la definizione del linguaggio C, senza suffissi o o costanti di
       tipo carattere.  Le costanti che iniziano per 0 sono interpretate come numeri ottali.  Uno
       0x  o 0X iniziale si usa per indicare numeri esadecimali. Altrimenti, i numeri prendono la
       forma [base#]n, dove l'opzionale base  è un numero decimale tra 2 e 64  che  definisce  la
       base  aritmetica,  e  n è un numero espresso in quella base. Se base# è omessa, è usata la
       base 10. Quando si specifica n, se è richesto un carattere che non sia una cifra, 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.  I comandi test e [ determinano  il  loro  comportamento  basato  sul  numero  d
       argomenti;  si  veda  la descrizione di questi comandi per ogni altra azione specifica del
       comando.

       Le espressioni sono formate dalle seguenti primitive  unarie  o  binarie.  Bash   manipola
       parecchi nomi-file specialmente quando sono usati in espressioni.  Se il sistema operativo
       nel quale Bash  è  in  esecuzione  fornisce  questi  file  speciali,  bash  userà  quelli;
       altrimenti  li  emulerà  internamente  con questo comportamento: se qualsiasi argomento di
       file di una delle primitive è della forma  /dev/fd/n,  il  descrittore  di  file  n  viene
       controllato.  Se  l'argomento  di  file  di  una  delle  primitive  è  uno tra /dev/stdin,
       /dev/stdout o /dev/stderr, il descrittore  di  file  0,  1  o  2,  rispettivamente,  viene
       controllato.

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

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

       -a file
              Vero se file esiste.
       -b file
              Vero se file esiste ed è un file speciale a blocchi.
       -c file
              Vero se file esiste ed è un file speciale a caratteri.
       -d file
              Vero se file esiste ed è una directory.
       -e file
              Vero se file esiste.
       -f file
              Vero se file esiste ed è un file normale.
       -g file
              Vero se file esiste ed è impostato il suo bit set-group-id.
       -h file
              Vero se file esiste ed è un collegamento simbolico.
       -k file
              Vero se file ha il suo “sticky” bit impostato.
       -p file
              Vero se file esiste ed è una named pipe (FIFO).
       -r file
              Vero se file esiste ed è leggibile.
       -s file
              Vero se file esiste ed è di dimensione maggiore di zero byte.
       -t fd  Vero se il descrittore di file fd è aperto e si tratta di un terminale.
       -u file
              Vero se file esiste ed è impostato il suo bit set-user-id.
       -w file
              Vero se file esiste ed è scrivibile.
       -x file
              Vero se file esiste ed è eseguibile.
       -G file
              Vero se file esiste ed è di proprietà del gruppo effettivo dell'utente.
       -L file
              Vero se file esiste ed è un collegamento simbolico.
       -N file
              Vero se file esiste ed è stato modificato dall'ultima volta che è stato letto.
       -O file
              Vero se file esiste ed è di proprietà dell'id utente effettivo.
       -S file
              Vero se file esiste ed è un socket.
       file1 -ef file2
              Vero se file1 e file2 fanno riferimento  allo  stesso  dispositivo  e  agli  stessi
              numeri di inode.
       file1 -nt file2
              Vero  se  file1  è più recente (come data di modifica) di file2 o se file1 esiste e
              file2 no.
       file1 -ot file2
              Vero se file1 è più vecchio di file2, o se file2 esiste e file1 no.
       -o optname
              Vero se l'opzione di shell optname è abilitata.  Si  veda  l'elenco  delle  opzioni
              sotto la descrizione dell'opzione -o al comando incorporato set più avanti.
       -v varname
              Vero se la variabile di shell varname è impostata (le è stato assegnato un valore).
       -R varname
              Vero  se la variabile di shell varname è impostata (le è stato assegnato un valore)
              ed è un riferimento a un nome.
       -z stringa
              Vero se la lunghezza di stringa è zero.
       stringa
       -n stringa
              Vero se la lunghezza di stringa è diversa da zero.

       stringa1 == stringa2
       stringa1 = stringa2
              Vero se le stringhe sono uguali. Col comando  test  dovrebbe  essere  usato  =  per
              conformità  con  lo  standard  POSIX.   Quando  è usato col comando [[, effettua la
              ricerca di corrispondenze come descritto precedentemente (Comandi composti).

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

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

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

       arg1 OP arg2
              OP è uno tra -eq, -ne, -lt, -le, -gt o  -ge.  Questi  operatori  aritmetici  binari
              risultano  veri  se  arg1  è, rispettivamente, uguale, non uguale, minore, minore o
              uguale, maggiore, o maggiore o uguale ad arg2. Arg1 e arg2  possono  essere  numeri
              interi  positivi  o  negativi.  Quando  è  usato  col  comando [[, Arg1 e Arg2 sono
              valutati come espressioni aritmetiche (vedi VALUTAZIONE ARITMETICA sopra).

ESPANSIONE DI COMANDO SEMPLICE

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

       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.

       If no command name results, the variable assignments affect the current shell environment.
       In the case of such a command  (one  that  consists  only  of  assignment  statements  and
       redirections),  assignment  statements  are performed before redirections.  Otherwise, the
       variables are added to the environment of the executed  command  and  do  not  affect  the
       current  shell  environment.   If  any  of the assignments attempts to assign a value to a
       readonly variable, an error occurs, and the command exits with a non-zero status.

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

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

ESECUZIONE DI UN COMANDO

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

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

       Se il nome non è né una funzione di shell né un comando incorporato, e non contiene alcuna
       barra [/], bash cerca tra gli elementi della variabile PATH una directory che contenga  un
       file  eseguibile  con  quel  nome. Bash usa una tabella hash [indicizzata] per ricordare i
       percorsi completi dei file eseguibili (si veda hash sotto COMANDI INCORPORATI DELLA  SHELL
       più  avanti). Una ricerca completa nelle directory in PATH è effettuata solo se il comando
       non viene trovato nella tabella hash. Se la ricerca non ha successo, la  shell  cerca  una
       funzione  di  shell,  già  definita, chiamata command_not_found_handle. Se questa funzione
       esiste, viene invocata in un ambiente di esecuzione separato col comando originale  e  gli
       argomenti  di quest'ultimo come suoi argomenti, e lo stato d'uscita della funzione diventa
       lo stato d'uscita di quella subshell. Se quella funzione non è definita, la  shell  stampa
       un messaggio di errore e ritorna uno stato d'uscita di 127.

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

       If this execution fails because the file is not in executable format, and the file is  not
       a directory, it is assumed to be a shell script, a file containing shell commands, and the
       shell creates a new instance of itself to execute it.  This subshell reinitializes itself,
       so  that  the  effect is as if a new shell had been invoked to handle the script, with the
       exception that the locations of commands remembered by the parent (see  hash  below  under
       SHELL BUILTIN COMMANDS)  are retained by the child.

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

AMBIENTE DI ESECUZIONE DEL COMANDO

       La shell ha un ambiente di esecuzione, costituito da:

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

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

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

       •      i segnali da intercettare impostati da trap

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

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

       •      opzioni  abilitate  all'invocazione  (sia  in modo predefinito che con argomenti da
              riga di comando) o da set

       •      opzioni abilitate da shopt

       •      alias di shell definiti da alias

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

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

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

       •      la directory di lavoro corrente

       •      la maschera del modo di creazione dei file

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

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

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

       A subshell is a copy of the shell process.

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

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

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

AMBIENTE

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

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

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

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

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

STATO DI USCITA

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

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

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

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

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

       The exit status of the last command is available in the special parameter $?.

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

SEGNALI

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

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

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

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

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

       When job control is not enabled, and bash is waiting for a foreground command to complete,
       the shell receives keyboard-generated signals such as SIGINT  (usually  generated  by  ^C)
       that  users  commonly  intend to send to that command.  This happens because the shell and
       the command are in the same process group as the terminal, and  ^C  sends  SIGINT  to  all
       processes in that process group.

       When  bash  is running without job control enabled and receives SIGINT while waiting for a
       foreground command, it waits until that foreground command  terminates  and  then  decides
       what to do about the SIGINT:

       1.     If  the command terminates due to the SIGINT, bash concludes that the user meant to
              end the entire script, and acts on the SIGINT (e.g., by running a  SIGINT  trap  or
              exiting itself);

       2.     If  the  command  does  not terminate due to SIGINT, the program handled the SIGINT
              itself and did not treat it as a fatal signal.  In that case, bash does  not  treat
              SIGINT as a fatal signal, either, instead assuming that the SIGINT was used as part
              of the program's normal operation (e.g., emacs uses it to abort  editing  commands)
              or  deliberately  discarded.   However, bash will run any trap set on SIGINT, as it
              does with any other trapped  signal  it  receives  while  it  is  waiting  for  the
              foreground command to complete, for compatibility.

JOB-CONTROL

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

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

              [1] 25647

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

       Per  facilitare  l'implementazione  dell'interfaccia utente per il job-control, il sistema
       mantiene la nozione di ID del gruppo di processi  del  terminale  corrente.  I  membri  di
       questo  gruppo  di processo (processi il cui ID del gruppo di processo è uguale all'ID del
       gruppo di processo del terminale corrente) ricevono segnali  generati  da  tastiera,  come
       SIGINT.  Si dice che questi processi sono in 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 primo piano è permesso di leggere o, se l'utente
       l'ha specificato con stty tostop, scrivere sul terminale. Ai processi nascosti che tentano
       di leggere dal terminale (o scriverci sopra quando stty tostop è in azione) è  inviato  un
       segnale  SIGTTIN  (SIGTTOU) dal driver del terminale del kernel, che, se non intercettato,
       sospende il processo.

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

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

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

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

       Se si tenta di uscire da bash mentre vi sono dei  job  sospesi(o,  se  è  stata  abilitata
       l'opzione di shell checkjobs usando il comando incorporato shopt, in esecuzione), la shell
       stampa un messaggio di avvertimento e, se viene abilitata l'opzione  checkjobs,  elenca  i
       job  e i loro stati. Si può quindi usare il comando jobs per controllare il loro stato. Se
       si fa un secondo tentativo per uscire senza immettere alcun altro comando, non  si  riceve
       più il messaggio di avvertimento e ogni job sospeso viene terminato.

       Quando la shell è in attesa di un job o di un processo usando il comando incorporato  wait
       e il job-control è abilitato,  wait ritornerà lo stato  di  completamento  quando  il  job
       cambia stato.  Con l'opzione  -f wait attende finché il job o il processo termina prima di
       ritornare.

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 mostra PS0 dopo aver letto un comando ma prima  di  eseguirlo.
       Bash mostra PS4 come descritto sopra prima di tracciare ciascun comando quando è abilitata
       l'opzione -x. Bash permette di personalizzare queste stringhe di prompt inserendo un certo
       numero  di  caratteri  speciali  preceduti  dalla barra inversa che sono decodificati come
       segue:
              \a     un carattere ASCII di campanello (07)
              \d     la data nel formato "Giorno-della-settimana Mese Giorno" (ad es.,  "Tue  May
                     26")
              \D{formato}
                     il  formato  viene  passato  a  strftime(3)  e il risultato è inserito nella
                     stringa di prompt; un formato vuoto genera una rappresentazione di  data/ora
                     specifica della localizzazione. Le parentesi graffe sono obbligatorie
              \e     un carattere ASCII di escape (033)
              \h     il nome dell'host fino al primo `.'
              \H     il nome dell'host
              \j     il numero di job attualmente gestiti dalla shell
              \l     il basename del terminale in cui è eseguita la shell
              \n     newline [su una nuova riga]
              \r     ritorno carrello
              \s     il  nome  della  shell, il basename di $0 (la parte che segue l'ultima barra
                     [/])
              \t     l'ora corrente nel formato HH:MM:SS 24 ore
              \T     l'ora corrente nel formato HH:MM:SS 12 ore
              \@     l'ora corrente nel formato am/pm 12 ore
              \A     l'ora corrente nel formato HH:MM 24 ore
              \u     il nome-utente dell'utente corrente
              \v     la versione di bash (ad es., 2.00)
              \V     la release di bash, versione + livello di patch (ad es., 2.00.0)
              \w     the value of the PWD shell variable ($PWD), with $HOME  abbreviated  with  a
                     tilde (uses the value of the PROMPT_DIRTRIM variable)
              \W     the basename of $PWD, with $HOME abbreviated with a tilde
              \!     il numero nella cronologia del comando attuale
              \#     il numero di comando del comando attuale
              \$     se l'UID effettivo è 0, un #, altrimenti un $
              \nnn   il carattere [ASCII] che corrisponde al numero ottale nnn
              \\     una barra inversa
              \[     marca  l'inizio  di una sequenza di caratteri non stampabili, che può essere
                     usata per includere nel prompt una sequenza di controllo del terminale
              \]     marca la fine di una sequenza di caratteri non stampabili

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

READLINE

       Questa è la  libreria  che  gestisce  la  lettura  dell'input  quando  si  usa  una  shell
       interattiva,  a  meno  che  non  si specifichi l'opzione --noediting all'invocazione della
       shell. La modifica di riga è usata anche quando viene  passata  l'opzione  -e  al  comando
       incorporato  read.  Come  comportamento  predefinito,  i  comandi  per l'editor della riga
       comandi sono simili a quelli di Emacs. È anche disponibile un'interfaccia  per  editor  di
       riga  in stile vi. La modifica di riga può essere abilitata in ogni momento con le opzioni
       -o emacs o -o vi del comando incorporato set (si veda COMANDI INCORPORATI DELLA SHELL  più
       avanti).  Per chiudere l'editor di riga dopo l'esecuzione della shell utilizzare l'opzione
       +o emacs o +o vi del comando incorporato set.

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

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

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

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

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

       Per esempio, porre

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

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

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

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

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

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

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

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

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

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

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

       In  aggiunta alle sequenze di protezione che iniziano col tasto escape in stile GNU Emacs,
       è disponibile un secondo insieme di sequenze di  protezione  che  iniziano  con  la  barra
       inversa:
              \a     avviso (segnale acustico)
              \b     backspace
              \d     cancella [delete - tasto Del o Canc]
              \f     salto pagina
              \n     newline [su una nuova riga]
              \r     ritorno carrello
              \t     tabulazione orizzontale
              \v     tabulazione verticale
              \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)

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

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

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

              set nome-variabile valore
       o usando il comando incorporato bind (si veda COMANDI INCORPORATI DELLA SHELL più avanti).

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

       active-region-start-color
              A  string  variable that controls the text color and background when displaying the
              text in the active region (see  the  description  of  enable-active-region  below).
              This string must not take up any physical character positions on the display, so it
              should consist only of terminal escape sequences.  It is  output  to  the  terminal
              before  displaying  the  text  in the active region.  This variable is reset to the
              default value whenever the terminal type changes.  The default value is the  string
              that  puts  the terminal in standout mode, as obtained from the terminal's terminfo
              description.  A sample value might be "\e[01;33m".
       active-region-end-color
              A string variable  that  "undoes"  the  effects  of  active-region-start-color  and
              restores  "normal"  terminal display appearance after displaying text in the active
              region.  This string must not take up  any  physical  character  positions  on  the
              display,  so  it should consist only of terminal escape sequences.  It is output to
              the terminal after displaying the text in the  active  region.   This  variable  is
              reset  to  the default value whenever the terminal type changes.  The default value
              is the string that restores the terminal from standout mode, as obtained  from  the
              terminal's terminfo description.  A sample value might be "\e[0m".
       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.
       blink-matching-paren (Off)
              Se impostato a On, readline tenta di  muovere  rapidamente  il  cursore  verso  una
              paretesi aperta quando è inserita una parentesi chiusa.
       colored-completion-prefix (Off)
              If  set to On, when listing completions, readline displays the common prefix of the
              set of possible completions using a different color.   The  color  definitions  are
              taken  from  the  value of the LS_COLORS environment variable.  If there is a color
              definition       in       $LS_COLORS       for       the       custom        suffix
              "readline-colored-completion-prefix",  readline  uses  this  color  for  the common
              prefix instead of its default.
       colored-stats (Off)
              Se impostata a On, readline visualizza  i  possibili  completamenti  usando  colori
              diversi  per indicare il tipo di file.   Le definizioni dei colori sono prese dalla
              variabile d'ambiente LS_COLORS.
       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-display-width (-1)
              Il numero di colonne sullo schermo per  visualizzare  le  possibili  corrispondenze
              quando  si  effettua  il  completamento.  Il  valore  è ignorato se è minore di 0 o
              maggiore della dimensione dello schermo. Con un valore di 0 viene visualizzata  una
              corrispondenza per riga. Il valore predefinito è -1.
       completion-ignore-case (Off)
              Se   impostato  a  On,  readline  effettua  l'individuazione  dei  nomi-file  e  il
              completamento senza distinguere le lettere maiuscole dalle lettere minuscole.
       completion-map-case (Off)
              Se impostato a On, e completion-ignore-case è abilitato, readline tratta i trattini
              (-)  e  i  trattini  bassi  (_)  come  equivalenti  quando  effettua  una ricerca e
              completamento di nomifile senza distinzione di minuscolo/maiuscolo.
       completion-prefix-display-length (0)
              La  lunghezza  in  caratteri  del  prefisso  comune  di  una  lista  di   possibili
              completamenti  che  è visualizzata senza modifiche.  Quando è impostata a un valore
              maggiore di zero, i prefissi comuni più lunghi di questo valore sono rimpiazzati da
              un'ellissi quando vengono visualizzati possibili completamenti.
       completion-query-items (100)
              This  determines  when  the  user  is  queried about viewing the number of possible
              completions generated by the possible-completions command.  It may be  set  to  any
              integer value greater than or equal to zero.  If the number of possible completions
              is greater than or equal to the value of this variable, readline will  ask  whether
              or  not  the  user  wishes  to  view  them; otherwise they are simply listed on the
              terminal.  A zero value means  readline  should  never  ask;  negative  values  are
              treated as zero.
       convert-meta (On)
              If  set to On, readline will convert characters with the eighth bit set to an ASCII
              key sequence by stripping the eighth bit and  prefixing  an  escape  character  (in
              effect, using escape as the meta prefix).  The default is On, but readline will set
              it to Off if the locale contains eight-bit characters.  This variable is  dependent
              on the LC_CTYPE locale category, and may change if the locale is changed.
       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.
       echo-control-characters (On)
              Quando  è  impostato  a  On,  sui  sistemi  operativi  che lo suppportano, readline
              visualizza un carattere corrispondente a un segnale generato dalla tastiera.
       editing-mode (emacs)
              Controlla se readline parte con un insieme di associazioni di tasti simile a  Emacs
              o vi. editing-mode (modalità di modifica) può essere impostato a emacs o a vi.
       emacs-mode-string (@)
              If   the   show-mode-in-prompt  variable  is  enabled,  this  string  is  displayed
              immediately before the last line of the primary prompt when emacs editing  mode  is
              active.  The value is expanded like a key binding, so the standard set of meta- and
              control prefixes and backslash escape sequences is available.  Use the  \1  and  \2
              escapes to begin and end sequences of non-printing characters, which can be used to
              embed a terminal control sequence into the mode string.
       enable-active-region (On)
              The point is the current cursor  position,  and  mark  refers  to  a  saved  cursor
              position.   The text between the point and mark is referred to as the region.  When
              this variable is set to On, readline  allows  certain  commands  to  designate  the
              region  as  active.  When the region is active, readline highlights the text in the
              region using the value of the  active-region-start-color,  which  defaults  to  the
              string that enables the terminal's standout mode.  The active region shows the text
              inserted by  bracketed-paste  and  any  matching  text  found  by  incremental  and
              non-incremental history searches.
       enable-bracketed-paste (On)
              When  set  to  On,  readline  configures the terminal to insert each paste into the
              editing buffer as a single string of characters, instead of treating each character
              as  if  it  had been read from the keyboard.  This prevents readline from executing
              any editing commands bound to key sequences appearing in the pasted text.
       enable-keypad (Off)
              Quando impostato a On, readline tenta di abilitare il tastierino numerico se  viene
              utilizzato. Alcuni sistemi richiedono questo per abilitare i tasti-freccia.
       enable-meta-key (On)
              Quando  è  impostato  a  On,  readline  tenta  di  abilitare  qualsiasi  meta tasto
              modificatore che il terminale dichiara di  supportare  quando  viene  chiamato.  Su
              molti terminali il meta tasto è usato per inviare caratteri a otto bit.
       expand-tilde (Off)
              Se  impostato  a On, l'espansione della tilde è effettuata quando readline tenta il
              completamento della parola.
       history-preserve-point (Off)
              Se impostato a On, il codice che implementa la  cronologia  tenta  di  piazzare  il
              cursore  nel punto in cui si trovava su ogni riga della cronologia visualizzata con
              previous-history o next-history.
       history-size (unset)
              Definisce il numero massimo di voci salvate nella cronologia.  Se impostata a zero,
              vengono  cancellate tutte le voci esistenti e nessuna nuova voce viene salvata.  Se
              impostata a un numero minore di zero, il  numero  di  registrazioni  è  illimitato.
              Come  impostazione  predefinita,  il  numero  di  voci di cronologia è impostato al
              valore della variabile di shell HISTSIZE .  Se si tenta di impostare history-size a
              un valore non numerico, il numero massimo di voci della cronologia sarà 500.
       horizontal-scroll-mode (Off)
              Quando  impostato  a  On,  richiede  a  readline  di  usare  una  sola  riga per la
              visualizzazione, facendo scorrere l'input in orizzontale su  una  sola  riga  dello
              schermo  quando  essa  risulti  più lunga della larghezza dello schermo, invece che
              andando a capo su una nuova riga. Qust'impostazione è abilitata automaticamente nei
              terminali di altezza 1.
       input-meta (Off)
              If  set to On, readline will enable eight-bit input (that is, it will not strip the
              eighth bit from the characters it reads), regardless of what the terminal claims it
              can  support.   The  name meta-flag is a synonym for this variable.  The default is
              Off, but readline will set it to On if the locale  contains  eight-bit  characters.
              This  variable  is dependent on the LC_CTYPE locale category, and may change if the
              locale is changed.
       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  e  C-J  fanno  terminare  una  ricerca
              incrementale.
       keymap (emacs)
              Imposta  la  mappa  corrente  dei  tasti di readline. Il set dei nomi validi per le
              mappe dei tasti è emacs, emacs-standard, emacs-meta, emacs-ctlx, vi,  vi-command  e
              vi-insert.  vi è equivalente a vi-command; emacs è equivalente a emacs-standard. Il
              valore predefinito è emacs; il valore di editing-mode determina anche la mappa  dei
              tasti predefiniti.
       keyseq-timeout (500)
              Specifica quanto tempo readline attenderà un carattere quando legge una sequenza di
              tasti ambigua (una che può formare una sequenza di tasti  completa  usando  l'input
              letto  finora,  o  può accettare un input aggiuntivo per completare una sequenza di
              tasti più lunga).  Se non riceve nessun input entro il tempo limite, readline userà
              la  sequenza  di  tasti  più corta tra quelle possibili. Il valore è specificato in
              millisecondi, cosicché un valore di  1000  vuol  dire  che  readline  attenderà  un
              secondo  per  un  input  aggiuntivo.   Se  questa variabile è impostata a un valore
              minore o uguale a zero, o a un valore non numerico, readline attenderà fino  a  che
              non sia premuto un altro tasto per decidere quale sequenza di tasti completare.
       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-file. Se impostata a Off, il `.' iniziale dev'essere fornito dall'utente  come
              parte del nome-file da completare.
       menu-complete-display-prefix (Off)
              Se  impostato  a  On, il completamento del menù visualizza il prefisso comune della
              lista  di  possibili  completamenti  (che  può  essere  vuota)  prima  di  scorrere
              ciclicamente la lista.
       output-meta (Off)
              If  set  to  On,  readline will display characters with the eighth bit set directly
              rather than as a meta-prefixed escape sequence.  The default is Off,  but  readline
              will  set  it  to On if the locale contains eight-bit characters.  This variable is
              dependent on the LC_CTYPE locale category, and may change if the locale is changed.
       page-completions (On)
              Se impostato a On, readline usa un paginatore interno simile a more per mostrare  i
              possibili completamenti una schermata alla volta.
       print-completions-horizontally (Off)
              Se  impostato  a  On, readline mostra i completamenti ordinati in ordine alfabetico
              orizzontalmente, piuttosto che dall'alto in basso.
       revert-all-at-newline (Off)
              Se impostato a On, readline annulla tutte le modifiche alle righe della  cronologia
              prima  di  ritornare,  quando  viene  eseguito accept-line. In modo predefinito, le
              righe della cronologia possono essere modificate e  mantengono  liste  dei  singoli
              anullamenti mediante chiamate a readline.
       show-all-if-ambiguous (Off)
              Questo  cambia  il  comportamento  predefinito  delle funzioni di completamento. Se
              impostato a On, le parole che hanno più di un possibile completamento provocano  la
              visualizzazione   immediata   delle   coincidenze   invece  che  l'attivazione  del
              segnalatore acustico.
       show-all-if-unmodified (Off)
              Questo cambia il comportamento  predefinito  delle  funzioni  di  completamento  in
              maniera  simile a show-all-if-ambiguous. Se impostato a On, le parole che hanno più
              di un possibile completamento senza alcun possibile completamento parziale  (ovvero
              i  possibili  completamenti  non  hanno  alcun  prefisso  in  comune) sono elencate
              immediatamente invece che provocare l'attivazione del segnalatore acustico.
       show-mode-in-prompt (Off)
              Se impostata a On, aggiunge  una  stringa  all'inizio  del  prompt  che  indica  la
              modalità di modifica:  emacs (@), vi comando (:) o vi inserimento (+).  Le stringhe
              della modalità sono impostabili dall'utente (p.es. emacs-mode-string).
       skip-completed-text (Off)
              Se impostato a On, altera il comportamento  predefinito  del  completamento  quando
              viene  inserita  una corrispondenza nella riga. È attivo solo quando si effettua il
              completamento a metà di una parola. Se abilitato, readline non inserisce,  dopo  il
              completamento   della   parola,   caratteri   provenienti   dal  completamento  che
              corrispondono ai caratteri della parola  da  completare  che  si  trovano  dopo  il
              cursore;  in  tal  modo  porzioni  di  parola  che  seguono  il cursore non vengono
              duplicati.
       vi-cmd-mode-string ((cmd))
              If  the  show-mode-in-prompt  variable  is  enabled,  this  string   is   displayed
              immediately  before  the  last  line  of the primary prompt when vi editing mode is
              active and in command mode.  The value is expanded  like  a  key  binding,  so  the
              standard  set  of  meta-  and  control  prefixes  and backslash escape sequences is
              available.  Use the \1 and \2 escapes to begin and end  sequences  of  non-printing
              characters,  which  can  be used to embed a terminal control sequence into the mode
              string.
       vi-ins-mode-string ((ins))
              If  the  show-mode-in-prompt  variable  is  enabled,  this  string   is   displayed
              immediately  before  the  last  line  of the primary prompt when vi editing mode is
              active and in insertion mode.  The value is expanded like a  key  binding,  so  the
              standard  set  of  meta-  and  control  prefixes  and backslash escape sequences is
              available.  Use the \1 and \2 escapes to begin and end  sequences  of  non-printing
              characters,  which  can  be used to embed a terminal control sequence into the mode
              string.
       visible-stats (Off)
              Se impostato a On, un carattere che denota  un  tipo  di  file  come  riportato  da
              stat(2) è accodato al nome-file durante l'elencazione dei possibili completamenti.

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

       $if    Il costrutto $if permette che le associazioni siano fatte in base alla modalità  di
              modifica,  al  terminale in uso o all'applicazione che fa uso di readline. Il testo
              da verificare, dopo qualsiasi operatore di confronto, arriva fino alla  fine  della
              riga;   a  meno  che  non  sia  diversamente  specificato, nessun  carattere che lo
              delimiti è richiesto.

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

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

              version
                     The version test  may  be  used  to  perform  comparisons  against  specific
                     readline  versions.   The  version  expands to the current readline version.
                     The set of comparison operators includes =, (and ==), !=, <=, >=, <, and  >.
                     The  version number supplied on the right side of the operator consists of a
                     major version number, an optional  decimal  point,  and  an  optional  minor
                     version (e.g., 7.1). If the minor version is omitted, it is assumed to be 0.
                     The operator may be separated from the string version and from  the  version
                     number argument by whitespace.

              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

              variabile
                     The variable construct provides simple equality tests for readline variables
                     and values.  The permitted comparison operators are  =,  ==,  and  !=.   The
                     variable  name must be separated from the comparison operator by whitespace;
                     the operator may be separated from the value  on  the  right  hand  side  by
                     whitespace.   Both  string  and  boolean  variables  may  be tested. Boolean
                     variables must be tested against the values on and off.

       $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-file  come  argomento  e  legge  comandi  e
              associazioni da quel file. Per esempio, la seguente direttiva legge /etc/inputrc:

              $include  /etc/inputrc

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

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

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

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

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

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

   Comandi di movimento
       beginning-of-line (C-a)
              Si sposta all'inizio della riga corrente.
       end-of-line (C-e)
              Si sposta alla fine della riga.
       forward-char (C-f)
              Si sposta avanti di un carattere.
       backward-char (C-b)
              Si sposta indietro di un carattere.
       forward-word (M-f)
              Si sposta in avanti fino alla fine della parola successiva. Le parole sono composte
              di caratteri alfanumerici (lettere e cifre).
       backward-word (M-b)
              Si  sposta  indietro  all'inizio della parola corrente o precedente. Le parole sono
              composte di caratteri alfanumerici (lettere e cifre).
       shell-forward-word
              Si sposta in avanti  fino  alla  fine  della  parola  successiva.  Le  parole  sono
              delimitate da metacaratteri di shell non quotati.
       shell-backward-word
              Si  sposta  indietro  all'inizio della parola corrente o precedente. Le parole sono
              delimitate da metacaratteri di shell non quotati.
       previous-screen-line
              Attempt to move point to the same physical screen column on the  previous  physical
              screen  line.  This  will  not have the desired effect if the current readline line
              does not take up more than one physical line or if point is not  greater  than  the
              length of the prompt plus the screen width.
       next-screen-line
              Attempt  to  move  point  to  the  same physical screen column on the next physical
              screen line. This will not have the desired effect if  the  current  readline  line
              does  not  take  up  more  than  one  physical line or if the length of the current
              readline line is not greater than the length of the prompt plus the screen width.
       clear-display (M-C-l)
              Clear the screen and, if possible, the terminal's scrollback  buffer,  then  redraw
              the current line, leaving the current line at the top of the screen.
       clear-screen (C-l)
              Pulisce  lo  schermo, poi riproduce la riga corrente, lasciando la riga corrente in
              cima allo schermo. Con un argomento, rilegge 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.
       operate-and-get-next (C-o)
              Accetta  la  riga  corrente  per  l'esecuzione  e  prende  dalla cronologia la riga
              successiva a quella corrente, per la modifica. Un argomento numerico, se  presente,
              specifica l'elemento della cronologia da usare al posto della riga corrente.
       fetch-history
              With  a  numeric  argument,  fetch that entry from the history list and make it the
              current line.  Without an argument, move back to the first  entry  in  the  history
              list.
       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.
       history-substring-search-backward
              Cerca  all'indietro  attraverso la cronologia una stringa di caratteri tra l'inizio
              della riga corrente e la posizione corrente del cursore (il punto). La  stringa  di
              ricerca  può cercare corrispondenze dovunque in una riga della cronologia. Questa è
              una ricerca non incrementale.
       history-substring-search-forward
              Cerca in avanti attraverso la cronologia una  stringa  di  caratteri  tra  l'inizio
              della  riga  corrente  e  il  punto del cursore.  La stringa di ricerca può cercare
              corrispondenze dovunque in una riga della cronologia.  Questa  è  una  ricerca  non
              incrementale.
       yank-nth-arg (M-C-y)
              Inserisce il primo argomento del comando precedente (generalmente la seconda parola
              sulla riga precedente) alla posizione del cursore. Con un argomento n, inserisce la
              n-sima parola del comando precedente (le parole nel comando precedente iniziano con
              la parola 0). Un argomento negativo inserisce  la  n-sima  parola  dalla  fine  del
              comando precedente. Una volta che l'argomento n è calcolato, l'argomento è estratto
              come se l'espansione della cronologia "!n" sia stata specificata.
       yank-last-arg (M-., M-_)
              Inserisce  l'ultimo  argomento  del  comando  precedente  (l'ultima  parola   della
              precedente  riga di cronologia). Con un argomento numerico, si comporta esattamente
              come yank-nth-arg. Chiamate consecutive a yank-last-arg percorrono  l'elenco  della
              cronologia  all'indietro,  inserendo  ogni  volta  l'ultima  parola  (o  la  parola
              specificata dall'argomento della prima chiamata) di ogni riga. Qualsiasi  argomento
              numerico fornito a queste chiamate successive determina la direzione di scorrimento
              nella cronologia.  Un  argomento  negativo  commuta  la  direzione  di  scorrimento
              (all'indietro  o  in avanti). I servizi dell'espansione della cronologia sono usati
              per estrarre l'ultima parola, come se fosse stata  specificata  l'espansione  della
              cronologia "!$".
       shell-expand-line (M-C-e)
              Espande la riga nello stesso modo in cui lo fa la shell. Questo espande gli alias e
              la cronologia così come tutte le parole  della  shell.  Si  veda  ESPANSIONE  DELLA
              CRONOLOGIA più avanti per una descrizione dell'espansione della cronologia.
       history-expand-line (M-^)
              Effettua  l'espansione  della  cronologia  sulla  riga corrente. Si veda ESPANSIONE
              DELLA CRONOLOGIA più avanti per una descrizione dell'espansione della cronologia.
       magic-space
              Effettua l'espansione della cronologia sulla riga corrente e inserisce uno  spazio.
              Si  veda ESPANSIONE DELLA CRONOLOGIA più avanti per una descrizione dell'espansione
              della cronologia.
       alias-expand-line
              Effettua l'espansione degli alias sulla riga corrente. Si veda ALIAS sopra per  una
              descrizione dell'espansione degli alias.
       history-and-alias-expand-line
              Espande la cronologia e gli alias sulla riga corrente.
       insert-last-argument (M-., M-_)
              Un sinonimo di yank-last-arg.
       edit-and-execute-command (C-x C-e)
              Invoca un editor sulla riga di comando corrente ed esegue il risultato come comandi
              di shell. Bash  tenta  di  invocare  $VISUAL,  $EDITOR  e  emacs  come  editor,  in
              quest'ordine.

   Comandi per cambiare il testo
       fine-del-file (generalmente C-e)
              Il carattere che indica fine-del-file come impostato, per esempio, da ``stty''.  If
              this character is read when there are no characters on the line, and  point  is  at
              the  beginning  of the line, readline interprets it as the end of input and returns
              EOF.
       delete-char (C-d)
              Cancella il carattere nel punto del cursore.  Se questa funzione è  associata  allo
              stesso  carattere  come il carattere EOF della tty, come C-d normalmente è, si veda
              sopra per gli effetti.
       backward-delete-char (Rubout)
              Cancella il carattere dopo il cursore. Quando è dato un argomento  numerico,  salva
              il testo cancellato sul kill-ring.
       forward-backward-delete-char
              Cancella  il  carattere  sotto  il cursore, a meno che il cursore non sia alla fine
              della riga, nel qual caso il carattere dietro al cursore viene cancellato.
       quoted-insert (C-q, C-v)
              Aggiunge il successivo carattere battuto sulla riga in modo letterale. Questo è  il
              modo per inserire caratteri come C-q, per esempio.
       tab-insert (C-v TAB)
              Inserisce un carattere tab.
       self-insert (a, b, A, 1, !, ...)
              Inserisce il carattere battuto.
       transpose-chars (C-t)
              Trascina  il carattere prima del punto del cursore in avanti sopra il carattere nel
              punto, spostando anche il punto in avanti. Se il punto  è  alla  fine  della  riga,
              traspone i due caratteri prima del punto. Argomenti negativi non hanno effetto.
       transpose-words (M-t)
              Trascina  la  parola  prima  del  punto  del cursore dopo la parola oltre il punto,
              spostando inoltre il punto sopra quella parola. Se il punto è alla fine della riga,
              allora traspone le ultime due parole sulla riga.
       upcase-word (M-u)
              Rende  maiuscola  la parola corrente (o seguente). Con un argomento negativo, opera
              sulla parola precedente, ma non sposta il punto del cursore.
       downcase-word (M-l)
              Rende minuscola la parola corrente (o seguente). Con un argomento  negativo,  opera
              sulla parola precedente, ma non sposta il punto del cursore.
       capitalize-word (M-c)
              Rende  maiuscola  la  prima  lettera  della  parola  corrente  (o seguente). Con un
              argomento negativo, opera sulla parola precedente,  ma  non  sposta  il  punto  del
              cursore.
       overwrite-mode
              Alterna  fra  modalità  inserimento  e modalità di sovrascrittura. Con un argomento
              numerico esplicito positivo passa alla modalità sovrascrittura.  Con  un  argomento
              numerico  esplicito  non  positivo  passa alla modalità inserimento. Questo comando
              riguarda solo la modalità emacs; la modalità vi sovrascrive in modo  diverso.  Ogni
              chiamata   a   readline()  viene  avviata  in  modalità  inserimento.  In  modalità
              sovrascrittura i caratteri associati a self-insert sostituiscono il testo nel punto
              del cursore piuttosto che sospingere il testo verso destra. I caratteri associati a
              backward-delete-char sostituiscono il carattere prima del  punto  con  uno  spazio.
              Questo comando è non associato in modo predefinito.

   Eliminazione e recupero
       kill-line (C-k)
              Elimina il testo dal punto del cursore fino alla fine della riga.
       backward-kill-line (C-x Rubout)
              Elimina all'indietro fino all'inizio della riga.
       unix-line-discard (C-u)
              Elimina  all'indietro  dal  punto  del cursore fino all'inizio della riga. Il testo
              eliminato viene salvato nel kill-ring.
       kill-whole-line
              Elimina tutti i caratteri sulla riga corrente, non importa dove sia  il  punto  del
              cursore.
       kill-word (M-d)
              Elimina  dal  punto  del  cursore  fino  alla  fine della parola corrente o, se tra
              parole, fino alla fine della successiva parola. I delimitatori di parola  sono  gli
              stessi usati da forward-word.
       backward-kill-word (M-Rubout)
              Elimina  la  parola  dietro il punto del cursore. I delimitatori di parole sono gli
              stessi usati da forward-word.
       shell-kill-word
              Elimina dal punto del cursore fino alla  fine  della  parola  corrente  o,  se  tra
              parole,  fino  alla fine della parola successiva. I delimitatori di parola sono gli
              stessi usati da shell-forward-word.
       shell-backward-kill-word
              Elimina la parola dietro il punto del cursore. I delimitatori di  parola  sono  gli
              stessi usati da shell-backward-word.
       unix-word-rubout (C-w)
              Elimina  la  parola  dietro  il  punto  del  cursore, usando gli spazi bianchi come
              delimitatori di parola. Il testo eliminato è salvato nel kill-ring.
       unix-filename-rubout
              Elimina la parola prima del punto del  cursore,  usando  uno  spazio  bianco  e  il
              carattere  barra  [/] come delimitatori di parola. Il testo eliminato è salvato nel
              kill-ring.
       delete-horizontal-space (M-\)
              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
              neitherneitherQuesto  è un altro modo per specificare un argomento. Se il comando è
              seguito da una o più cifre, opzionalmente con un segno meno iniziale, queste  cifre
              definiscono   l'argomento.   Se   il   comando   è   seguito  da  cifre,  eseguendo
              universal-argument di nuovo termina l'argomento numerico, ma a parte  questo  viene
              ignorato.  Come  caso  speciale,  se  questo comando è seguito immediatamente da un
              carattere che non è né una cifra né un segno meno, il contatore degli argomenti per
              il  comando successivo è moltiplicato per quattro. Il contatore è inizialmente uno,
              così eseguendo questa funzione la prima volta  il  contatore  diventa  quattro,  la
              seconda volta il contatore diventa sedici, e così via.

   Completamento
       complete (TAB)
              Tenta  di  effettuare  il completamento del testo che precede il punto del cursore.
              Bash tenta il completamento trattando il testo, rispettivamente, come una variabile
              (se  il  testo  inizia con $), nome di utente (se il testo comincia con ~), nome di
              host (se il testo comincia con @) o comando (inclusi alias e funzioni). Se  nessuno
              di questi produce un risultato, viene tentato il completamento del nome-file.
       possible-completions (M-?)
              Elenca i possibili completamenti del testo che precede il punto del cursore.
       insert-completions (M-*)
              Inserisce  tutti  i  completamenti  del  testo che precede il punto del cursore che
              sarebbero stati generati da possible-completions.
       menu-complete
              Simile a complete, ma sostituisce la parola da completare  con  una  corrispondenza
              singola   dalla  lista  dei  possibili  completamenti.  Un'esecuzione  ripetuta  di
              menu-complete  scorre  la  lista  dei  possibili   completamenti,   inserendo   una
              corrispondenza  alla volta. Alla fine della lista dei completamenti viene emesso un
              segnale acustico (dipendente dall'impostazione di bell-style) e il testo  originale
              è  ripristinato.  Con un argomento n si sposta di n posizioni in avanti nella lista
              dei completamenti individuati; può essere usato un argomento negativo per spostarsi
              all'indietro  nella lista. Questo comando è da associare normalmente al tasto TABP,
              però non è associato in modo predefinito.
       menu-complete-backward
              Identico a menu-complete, ma si muove in senso inverso nella  lista  dei  possibili
              completamenti,  come  se  menu-complete avesse ricevuto un argomento negativo. Come
              comportamento predefinito, questo comando non ha restrizioni.
       delete-char-or-list
              Cancella il carattere sotto il cursore se non si trova all'inizio o alla fine della
              riga  (simile  a  delete-char).  Se  è  alla  fine  della riga, si comporta in modo
              identico a possible-completions. Come comportamento predefinito, questo comando non
              è associato.
       complete-filename (M-/)
              Tenta  il  completamento  del  nome  del  file  sul  testo che precede il punto del
              cursore.
       possible-filename-completions (C-x /)
              Elenca i possibili completamenti del  testo  che  precede  il  punto  del  cursore,
              trattandolo come un nome-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-file eseguibili, in quest'ordine.
       possible-command-completions (C-x !)
              Elenca i possibili completamenti del  testo  che  precede  il  punto  del  cursore,
              trattandolo come un nome di comando.
       dynamic-complete-history (M-TAB)
              Tenta  il completamento del testo che precede il cursore, confrontando il testo con
              le righe della cronologia cercando le possibili corrispondenze di completamento.
       dabbrev-expand
              Tenta il completamento del menù  sul  testo  che  precede  il  punto  del  cursore,
              confrontando  il  testo  con  le  righe  della  lista  della cronologia cercando le
              possibili corrispondenze di completamento.
       complete-into-braces (M-{)
              Effettua il  completamento  del  nome-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.
       print-last-kbd-macro ()
              Stampa l'ultima macro di tastiera  definita  in  un  formato  adatto  per  il  file
              inputrc.

   Varie
       re-read-init-file (C-x C-r)
              Legge  il  contenuto del file inputrc, e incorpora ogni associazione o assegnamento
              di variabile che trova.
       abort (C-g)
              Annulla il corrente  comando  di  mmodifica  ed  emette  il  segnale  acustico  del
              terminale (dipendente dall'impostazione di bell-style).
       do-lowercase-version (M-A, M-B, M-x, ...)
              Se  il  carattere  x  battuto  assieme al tasto Meta è maiuscolo, esegue il comando
              collegato al corrispondente carattere minuscolo.  Il comportamento è indefinito  se
              x è già minuscolo.
       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-])
              A character is read and point is moved to the next occurrence of that character.  A
              negative argument searches for previous occurrences.
       character-search-backward (M-C-])
              A  character  is  read  and  point  is  moved  to  the  previous occurrence of that
              character.  A negative argument searches for subsequent occurrences.
       skip-csi-sequence
              Legge abbastanza caratteri da esaurire una sequenza di combinazione di  tasti  come
              quelle definite per tasti quali Home e End. Queste sequenze iniziano con un Control
              Sequence Indicator (CSI), generalmente ESC-[. Se  questa  sequenza  è  collegata  a
              "\[",  i  tasti che producono tali sequenze non hanno alcun effetto, a meno che non
              siano collegati esplicitamente a un comando readline, invece di inserire  caratteri
              sparsi nel buffer di modifica. Come impostazione predefinita, questo comando non ha
              restrizioni, ma in genere è collegato a ESC-[.
       insert-comment (M-#)
              Senza un argomento numerico il valore  della  variabile  readline  comment-begin  è
              inserito  all'inizio della riga corrente. Se è fornito un argomento numerico questo
              comando agisce come un interruttore: se  i  caratteri  all'inizio  della  riga  non
              corrispondono  al  valore  di comment-begin, il valore viene inserito, altrimenti i
              caratteri in comment-begin vengono cancellati dall'inizio della riga. In entrambi i
              casi  la  riga  viene  accettata come se fosse stato battuto un codice di fine riga
              (newline). Il  valore  predefinito  di  comment-begin  fa  sì  che  questo  comando
              trasformi  la  riga  corrente  in  un  commento  di shell. Se un argomento numerico
              provoca la rimozione del carattere di commento, la riga verrà eseguita dalla shell.
       spell-correct-word (C-x s)
              Perform spelling correction on the current word, treating  it  as  a  directory  or
              filename,  in  the  same  way as the cdspell shell option.  Word boundaries are the
              same as those used by shell-forward-word.
       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-file individuati viene inserita,  sostituendo  la
              parola.  Se  viene  fornito  un  argomento  numerico  viene  aggiunto  alla fine un
              asterisco prima dell'espansione del percorso.
       glob-list-expansions (C-x g)
              Viene  mostrata  la  lista  delle  espansioni  che  sarebbero  state  generate   da
              glob-expand-word  e  la riga è ridisegnata. Se viene fornito un argomento numerico,
              un asterisco è aggiunto prima dell'espansione del percorso.
       dump-functions
              Stampa tutte le funzioni e le loro associazioni di tasti  sul  file  di  output  di
              readline. Se è fornito un argomento numerico, l'output è formattato in modo tale da
              poter essere inserito in un file inputrc.
       dump-variables
              Stampa tutte le variabili readline impostabili e i loro valori sul file  di  output
              di  readline.  Se viene fornito un argomento numerico l'output è formattato in modo
              tale da poter essere inserito in un file inputrc.
       dump-macros
              Stampa tutte le sequenze di tasti readline associate a macro e le stringhe da  loro
              prodotte. Se viene fornito un argomento numerico l'uscita è formattata in modo tale
              da poter essere inserito in un file inputrc.
       display-shell-version (C-x C-v)
              Mostra l'informazione sulla versione della corrente istanza di bash.

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

       Per  prima  cosa  viene  identificato  il  nome del comando. Se la parola del comando è la
       stringa vuota (completamento tentato all'inizio di  una  riga  vuota),  viene  usato  ogni
       compspec  definito  con  l'opzione -E di complete. Se un comspec è stato definito per quel
       comando, il comspec è usato per generare la  lista  dei  possibili  completamenti  per  la
       parola.  Se  il nome del comando è un percorso completo di file, viene ricercato per primo
       un comspec per il percorso completo. Se non viene trovato nessun comspec per  il  percorso
       completo  viene  fatto  un  tentativo  per trovare un comspec per la porzione che segue la
       barra [/] finale. Se queste ricerche non  risultano  in  un  compspec,  viene  usato  come
       predefinito  ogni  compspec  definito  con l'opzione -D di complete. Se non c'è un comspec
       predefinito, bash tenta l'espansione  dell'alias  sulla  parola  di  comando  come  ultima
       alternativa,  e  tenta  di  trovare un comspec per la parola di comando da ogni espansione
       andata a buon fine.

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

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

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

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

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

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

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

       Una  volta generati tutti i possibili completamenti, ogni filtro specificato con l'opzione
       -X viene applicato alla lista. Il filtro è un modello come quello usato  per  l'espansione
       di  percorso;  una  & nel modello è sostituita col testo della parola da completare. Una &
       letterale si può indicare con una barra inversa di  protezione;  la  barra  inversa  viene
       rimossa  prima  della ricerca di una corrispondenza. Ogni completamento che corrisponde al
       modello viene rimosso dalla lista. Un ! iniziale nega il  modello;  in  questo  caso  ogni
       completamento  non  corrispondente  al  modello  viene  rimosso.    Se  l'opzione di shell
       nocasematch è abilitata, il confronto è  effettuato  senza  distinzione  fra  maiuscole  e
       minuscole nei caratteri alfabetici.

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

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

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

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

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

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

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

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

STORIA

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

       All'avvio,  la  cronologia  è  inizializzata  dal  file  indicato dalla variabile HISTFILE
       (predefinita ~/.bash_history). Il file indicato dal valore di HISTFILE viene troncato,  se
       necessario,  per  contenere  non  più  del  numero  di  righe  specificate  dal  valore di
       HISTFILESIZE. Se HISTFILESIZE non è impostata,  o  impostata  a  null,  a  un  valore  non
       numerico o a un valore minore di zero, il file della cronologia non viene troncato. Quando
       viene letto il file della cronologia, le righe che iniziano con un carattere di  commento,
       seguito  immediatamente  da una cifra, sono interpretate come marcatura oraria per la riga
       che segue. Queste informazioni di data e ora vengono visualizzate opzionalmente a  seconda
       del  valore  della  variabile HISTTIMEFORMAT. Quando una shell con la cronologia abilitata
       esce, le ultime $HISTSIZE righe vengono copiate dalla lista della cronologia su $HISTFILE.
       Se  l'opzione  di  shell  histappend  è  abilitata  (si veda la descrizione di shopt sotto
       COMANDI INCORPORATI DELLA SHELL più avanti), le  righe  vengono  accodate  al  file  della
       cronologia, in caso contrario il file della cronologia viene sovrascritto. Se HISTFILE non
       è impostato o il file della cronologia è non scrivibile, la cronologia non viene  salvata.
       Se  la variabile HISTTIMEFORMAT è impostata, le informazioni di data e ora vengono scritte
       nel file della cronologia, contrassegnate col carattere di commento della  cronologia,  in
       modo  da  venir  preservate  durante  le sessioni di shell. Il carattere di commento viene
       usato per distinguere le informazioni di data e ora dalle altre righe. Dopo il salvataggio
       della cronologia il file della cronologia è troncato per contenere non più di HISTFILESIZE
       righe. Se HISTFILESIZE non è impostata, o impostata a null, a un valore non numerico  o  a
       un valore numerico minore di zero, il file della cronologia non viene troncato.

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

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

ESPANSIONE DELLA CRONOLOGIA

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

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

       L'espansione della cronologia è effettuata immediatamente dopo che  una  riga  completa  è
       stata  letta,  prima  che  la  shell la divida in parole, ed è effettuata su ciascuna riga
       senza tener conto delle quotatute sulle righe precedenti. Essa ha luogo in due  parti.  La
       prima  è  per  determinare  quale  riga  dall'elenco  della  cronologia  usare  durante la
       sostituzione. La seconda è per selezionare parti di quella riga da  includere  nella  riga
       corrente.  La  riga  selezionata dalla cronologia è l'evento, e la parte di quella riga su
       cui si agisce sono le parole. Diversi modificatori  sono  disponibili  per  manipolare  le
       parole  selezionate.  La  riga  è spezzata in parole allo stesso modo di quando è letta in
       input, così che più parole separate da metacaratteri circondate da caratteri di  quotatura
       sono  considerate  come  una  sola  parola. Le espansioni della cronologia iniziano con la
       comparsa di un carattere di espansione della cronologia, che è ! in modo predefnito.  Solo
       la  barra  inversa  (\)  e  gli apostrofi possono quotare il carattere di espansione della
       cronologia, ma il carattere di espansione della cronologia è trattato come quotato se esso
       precede immediatamente le virgolette di chiusura in una stringa tra virgolette.

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

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

       La shell permette il controllo dei vari caratteri usati dal meccanismo di espansione della
       cronologia  (si  veda la precedente descrizione di histchars sotto Variabili di shell). La
       shell usa il carattere di commento per contrassegnare le informazioni di data e ora quando
       scrive il file della cronologia.

   Designatore di evento
       Un  designatore  di  evento  è un riferimento a un elemento di riga di comando nella lista
       della cronologia. A meno che il riferimento non sia assoluto,  gli  eventi  sono  relativi
       alla posizione corrente nell'elenco della cronologia.

       !      Inizia  una sostituzione di cronologia, tranne quando seguita da un blank, newline,
              carriage return, = o ( (quando l'opzione di shell extglob  è  abilitata  usando  il
              comando incorporato shopt).
       !n     Designa la riga di comando n.
       !-n    Designa il comando corrente meno n.
       !!     Designa il comando precedente. Questo è un sinonimo per `!-1'.
       !stringa
              Designa  il comando più recente che precede la posizione corrente nell'elenco della
              cronologia che inizia con stringa.
       !?stringa[?]
              Designa il comando più recente che precede la posizione corrente nell'elenco  della
              cronologia che contiene stringa. Il ? finale può essere omesso se stringa è seguita
              immediatamente da un codice di fine riga (newline). Se stringa manca,  viene  usata
              la  stringa  dalla  ricerca  più  recente;  è  un  errore se non ci sono precedenti
              stringhe di ricerca.
       ^stringa1^stringa2^
              Sostituzione rapida.  Ripete  il  comando  precedente,  rimpiazzando  stringa1  con
              stringa2.  Equivalente  a  “!!:s^stringa1^stringa2^”   (si  veda  Modificatori  più
              avanti).
       !#     L'intera riga di comando battuta fino a questo punto.

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

       0 (zero)
              La parola numero zero. Per la shell, questa è la parola che costituisce il nome del
              comando.
       n      La n-esima parola.
       ^      Il primo argomento. Cioè, la parola 1.
       $      L'ultima  parola.  Normalmente  questo  è  l'ultimo argomento, ma si espanderà alla
              parola numero zero se c'è una sola parola nella riga.
       %      La prima parola che combacia con `?stringa?'  nella  più  recente  ricerca,  se  la
              stringa di ricerca inizia con un carattere che è parte di una parola .
       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 manca x , il valore predefinito
              è 0.

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

   Modificatori
       After  the  optional  word  designator,  there may appear a sequence of one or more of the
       following modifiers, each preceded by a `:'.  These modify, or edit,  the  word  or  words
       selected from the history event.

       h      Rimuove un componente finale in un nome-file, lasciando solo la testa.
       t      Rimuove tutti i componenti iniziali in un nome-file, lasciando la coda.
       r      Rimuove un suffisso finale della forma .xxx, lasciando il nome base (basename).
       e      Rimuove tutto tranne il suffisso finale.
       p      Stampa il nuovo comando ma non lo esegue.
       q      Quota le parole sostituite, prevenendo ulteriori sostituzioni.
       x      Quota  le parole sostituite, come con q, ma spezza in parole sui blank e newline. I
              modificatori q e x sono mutualmente esclusivi; viene usato l'ultimo fornito.
       s/vecchio/nuovo/
              Sostituisce nuovo alla prima occorrenza di vecchio nella riga di evento.  Qualsiasi
              carattere può essere usato come delimitatore al posto di /.  Il delimitatore finale
              è opzionale se esso è l'ultimo carattere della riga di evento. Il delimitatore  può
              essere  quotato  in  vecchio e nuovo con una singola barra inversa. Se compare & in
              nuovo, esso è sostituito da vecchio. Una barra inversa singola quota  il  carattere
              &.  Se vecchio è nullo, viene impostato all'ultimo vecchio sostituito o, se nessuna
              sostituzione  di  cronologia  è  avvenuta,  l'ultima  stringa  in  una  ricerca  di
              !?string[?]. Se nuovo è nullo, ogni corrispondenza di vecchio viene cancellata.
       &      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'  o `&'  una volta a ogni parola nella riga di
              evento.

COMANDI INCORPORATI DELLA SHELL

       Se non diversamente indicato, ogni comando incorporato documentato in questa  sezione,  il
       quale  accetti  opzioni  precedute  da -, accetta -- per indicare la fine delle opzioni. I
       comandi incorporati :, true, false, e test non accettano opzioni e non trattano -- in modo
       speciale.  I  comandi  incorporati  exit,  logout,  return,  break,  continue, let e shift
       accettano ed elaborano argomenti che iniziano con - senza  richiedere  --.  Altri  comandi
       incorporati  che  accettano  argomenti, ma per i quali non viene specificato che accettano
       opzioni, interpretano gli  argomenti  che  iniziano  con  -  come  opzioni  non  valide  e
       richiedono -- per impedire questa interpretazione.
       : [argomenti]
              Nessun  effetto;  il  comando  non fa niente, tranne l'espansione degli argomenti e
              l'effettuazione di ogni ridirezione specificata.  Lo stato di ritorno è zero.

        .  nome-file [argomenti]
       source nome-file [argomenti]
              Read and execute commands from filename in the current shell environment and return
              the  exit  status of the last command executed from filename.  If filename does not
              contain a slash, filenames in PATH  are  used  to  find  the  directory  containing
              filename,  but  filename  does not need to be executable.  The file searched for in
              PATH need not be executable.  When bash is not  in  posix  mode,  it  searches  the
              current  directory  if  no  file is found in PATH.  If the sourcepath option to the
              shopt builtin command is turned off, the PATH is not searched.   If  any  arguments
              are  supplied,  they  become  the  positional parameters when filename is executed.
              Otherwise the positional parameters are unchanged.  If the -T option is enabled,  .
              inherits  any  trap  on  DEBUG;  if  it  is not, any DEBUG trap string is saved and
              restored around the call to ., and . unsets the DEBUG trap while it  executes.   If
              -T  is  not  set,  and  the  sourced  file changes the DEBUG trap, the new value is
              retained when . completes.  The return status is the status  of  the  last  command
              exited  within the script (0 if no commands are executed), and false if filename is
              not found or cannot be read.

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

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

       bind [-m keymap] [-lpsvPSVX]
       bind [-m keymap] [-q funzione] [-u funzione] [-r keyseq]
       bind [-m keymap] -f nome-file
       bind [-m keymap] -x keyseq:comando di shell
       bind [-m keymap] keyseq:nome-funzione
       bind [-m mappa-tasti] sequenza-tasti:comando readline
       bind readline-command-line
              Display current readline key and function  bindings,  bind  a  key  sequence  to  a
              readline  function  or macro, or set a readline variable.  Each non-option argument
              is a command as it would appear in a readline initialization file such as .inputrc,
              but  each  binding  or  command  must  be  passed  as  a  separate  argument; e.g.,
              '"\C-x\C-r":  re-read-init-file'.   Options,  if  supplied,  have   the   following
              meanings:
              -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 (anche vi-move è un sinonimo) ; emacs è equivalente
                     a emacs-standard.
              -l     Elenca i nomi di tutte le funzioni di readline.
              -p     Mostra  i  nomi delle funzioni di readline e delle loro associazioni in modo
                     tale che possano essere riletti.
              -P     Elenca i nomi delle funzioni di readline correnti e le loro associazioni.
              -s     Mostra sequenze di tasti  di  readline  associati  a  macro  e  le  stringhe
                     risultanti in modo tale che possano essere rilette.
              -S     Mostra  sequenze  di  tasti  di  readline  associate  a  macro e le stringhe
                     risultanti.
              -v     Mostra i nomi delle variabili di readline e i loro valori in modo  tale  che
                     possano essere riletti.
              -V     Elenca i nomi delle variabili di readline correnti e i loro valori.
              -f nome-file
                     Legge le associazioni dei tasti dal file nome-file.
              -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
                     Cause  shell-command  to  be  executed  whenever  keyseq  is  entered.  When
                     shell-command is executed, the shell sets the READLINE_LINE variable to  the
                     contents   of   the   readline   line  buffer  and  the  READLINE_POINT  and
                     READLINE_MARK variables to the current location of the insertion  point  and
                     the  saved  insertion point (the mark), respectively.  The shell assigns any
                     numeric argument the user supplied to the  READLINE_ARGUMENT  variable.   If
                     there  was  no  argument, that variable is not set.  If the executed command
                     changes the value of any of READLINE_LINE, READLINE_POINT, or READLINE_MARK,
                     those new values will be reflected in the editing state.
              -X     Elenca  tutte  le sequenze di tasti associati a comandi di shell e i comandi
                     associati in un formato che può essere riusato come input.

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

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

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

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

       cd [-L|[-P [-e]] [-@]] [dir]
              Change the current directory to dir.  if dir is not supplied, the value of the HOME
              shell variable is the default.  The variable CDPATH defines the search path for the
              directory containing dir: each directory  name  in  CDPATH  is  searched  for  dir.
              Alternative  directory  names  in  CDPATH  are  separated  by  a colon (:).  A null
              directory name in CDPATH is the same as the current directory, i.e., “.”.   If  dir
              begins  with  a slash (/), then CDPATH is not used.  The -P option causes cd to use
              the physical directory structure by resolving symbolic links while  traversing  dir
              and  before  processing  instances  of .. in dir (see also the -P option to the set
              builtin command); the -L option forces symbolic links to be followed  by  resolving
              the  link  after  processing  instances  of .. in dir.  If .. appears in dir, it is
              processed by removing the immediately previous pathname component from dir, back to
              a  slash  or  the  beginning of dir.  If the -e option is supplied with -P, and the
              current working directory cannot be  successfully  determined  after  a  successful
              directory  change,  cd will return an unsuccessful status.  On systems that support
              it, the -@ option presents the extended attributes associated  with  a  file  as  a
              directory.  An argument of - is converted to $OLDPWD before the directory change is
              attempted.  If a non-empty directory name from CDPATH is used, or if - is the first
              argument,  and the directory change is successful, the absolute pathname of the new
              working directory is written to the standard output.  If the  directory  change  is
              successful,  cd sets the value of the PWD environment variable to the new directory
              name, and sets the OLDPWD environment variable to the value of the current  working
              directory  before  the  change.   The  return  value  is  true if the directory was
              successfully changed; false otherwise.

       command [-pVv] comando [arg ...]
              Esegue comando con gli argomenti sopprimendo la normale ricerca tra le funzione  di
              shell.  Sono  eseguiti  solo  i comandi incorporati o comandi trovati in PATH. Se è
              specificata l'opzione -p, la ricerca di comando viene effettuata usando  un  valore
              predefinito per PATH usando il quale è garantito che siano trovate tutte le utilità
              standard. Se è fornita l'opzione  -V  o  -v,  viene  stampata  una  descrizione  di
              comando.  L'opzione  -v provoca la visualizzazione di una singola parola che indica
              il comando o il nome-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]  [-DEI]  [-A   azione]   [-G   globpat]   [-W
       lista_di_parole]
              [-F  funzione]  [-C  comando] [-X filterpat] [-P prefisso] [-S suffisso] nome [nome
              ...]
       complete -pr [-DEI] [nome ...]
              Specify how arguments to each name should  be  completed.   If  the  -p  option  is
              supplied,  or  if  no  options are supplied, existing completion specifications are
              printed in a way that allows them to be reused as input.  The -r option  removes  a
              completion  specification  for  each  name,  or,  if  no  names  are  supplied, all
              completion specifications.  The -D option indicates that other supplied options and
              actions  should  apply  to  the  “default”  command completion; that is, completion
              attempted on a command for which no completion has previously been defined.  The -E
              option  indicates  that  other supplied options and actions should apply to “empty”
              command completion; that is, completion attempted on a blank line.  The  -I  option
              indicates that other supplied options and actions should apply to completion on the
              initial non-assignment word on the line, or after a command delimiter such as ;  or
              |, which is usually command name completion.  If multiple options are supplied, the
              -D option takes precedence over -E, and both take precedence over -I.   If  any  of
              -D, -E, or -I are supplied, any other name arguments are ignored; these completions
              only apply to the case specified by the option.

              The process of applying these completion specifications  when  word  completion  is
              attempted is described above under Programmable Completion.

              Altre  opzioni,  se  specificate,  hanno i seguenti significati. Gli argomenti alle
              opzioni  -G, -W, e -X (e, se necessario alle opzioni  -P e  -S)  dovrebbero  essere
              quotati  per  proteggerli  dall'espansione  prima  che  venga  invocato  il comando
              incorporato complete.
              -o comp-option
                      L'opzione  comp-option  controlla  diversi  aspetti  del  comportamento  di
                      comspec  oltre  la  semplice  generazione di completamenti. comp-option può
                      essere uno di questi:
                      bashdefault
                              Effettua il resto dei completamenti predefiniti di bash se  comspec
                              non genera corrispondenze.
                      default Usa  il  completamento  del  nome-file  predefinito  di readline se
                              comspec non genera corrispondenze.
                      dirnames
                              Effettua il completamento del nome  di  directory  se  comspec  non
                              genera corrispondenze.
                      filenames
                              Dice  a  readline che il comspec genera nomi-file, consentendo così
                              di effettuare qualsiasi elaborazione  di  uno  specifico  nome-file
                              (come  aggiungere  una  barra  [/]  ai  nomi  di directory, quotare
                              caratteri speciali o sopprimere gli spazi finali). Fatto per essere
                              usato con le funzioni di shell.
                      noquote Dice  a  readline  di  non  quotare  le  parole  completate se sono
                              nomi-file  (la  quotatura  dei   nomi-file   è   il   comportamento
                              predefinito).
                      nosort  Dice   a   readline   di   non  ordinare  la  lista  dei  possibili
                              completamenti in ordine alfabetico.
                      nospace Dice a readline di non aggiungere uno spazio (che viene aggiunto in
                              modo predefinito) alle parole completate alla fine della riga.
                      plusdirs
                              Dopo che le corrispondenze definite da comspec sono state generate,
                              viene tentato il completamento dei nomi di directory e il risultato
                              viene aggiunto ai risultati delle altre azioni.
              -A azione
                      L'azione  può essere una delle seguenti per generare una lista di possibili
                      completamenti:
                      alias   Nome di alias. Può anche essere specificata come -a.
                      arrayvar
                              Nomi di variabili di array.
                      binding Nomi di associazioni di tasti Readline.
                      builtin Nomi  di  comandi  incorporati  della  shell.  Può   anche   essere
                              specificata come -b.
                      command Nomi di comandi. Può anche essere specificata come -c.
                      directory
                              Nomi di directory.  Può anche essere specificata come -d.
                      disabled
                              Nomi di comandi incorporati della shell disabilitati.
                      enabled Nomi di comandi incorporati della shell abilitati.
                      export  Nomi  di variabili di shell esportate. Può anche essere specificata
                              come -e.
                      file    Nomi di file. Può anche essere specificata come -f.
                      function
                              Nomi di funzioni di shell.
                      group   Nomi di gruppo. Può anche essere specificata come -g.
                      helptopic
                              Argomenti di aiuto come accettati dal comando incorporato help.
                      hostname
                              Nomi di host, come presi dal file specificato  dalla  variabile  di
                              shell HOSTFILE.
                      job     Nomi  di  job,  se  il  job-control  è  attivo.  Può  anche  essere
                              specificata come -j.
                      keyword Parole riservate della shell. Può anche essere specificata come -k.
                      running Nomi di job in esecuzione, se il job-control è attivo.
                      service Nome di servizi. Può anche essere specificata come -s.
                      setopt  Argomenti validi per l'opzione -o del comando incorporato set.
                      shopt   Nomi di opzioni di shell come  accettati  dal  comando  incorporato
                              shopt.
                      signal  Nomi di segnali.
                      stopped Nomi di job sospesi, se il job-control è attivo.
                      user    Nomi di utente. Può anche essere specificata come -u.
                      variable
                              Nomi di variabili di shell. Può anche essere specificata come -v.
              -C comando
                      command  is  executed  in a subshell environment, and its output is used as
                      the possible completions.  Arguments are passed as with the -F option.
              -F funzione
                      La funzione  di  shell  function  viene  eseguita  nell'ambiente  di  shell
                      corrente.   Quando  la  funzione è eseguita, il primo argomento  ($1)  è il
                      nome del comando i cui  argomenti  devono  essere  completati,  il  secondo
                      argomento   ($2)  è la parola da completare, e il terzo argomento ($3) è la
                      parola che precede la parola da completare sulla riga di comando  corrente.
                      Al  termine,  i  completamenti  possibili  sono recuperati dal valore della
                      variabile array COMPREPLY .
              -G globpat
                      Il modello di espansione dei nomi di percorso  globpat  viene  espanso  per
                      generare i possibili completamenti.
              -P prefisso
                      prefisso  è  aggiunto  all'inizio  di ogni possibile completamento dopo che
                      sono state applicate tutte le altre opzioni.
              -S suffisso
                      suffisso è aggiunto alla fine di ogni possibile completamento dopo che sono
                      state applicate tutte le altre opzioni.
              -W wordlist
                      The  wordlist  is split using the characters in the IFS special variable as
                      delimiters, and each resultant word is expanded.  Shell quoting is  honored
                      within  wordlist,  in order to provide a mechanism for the words to contain
                      shell metacharacters or characters in  the  value  of  IFS.   The  possible
                      completions  are  the  members  of  the resultant list which match the word
                      being completed.
              -X filterpat
                      filterpat  è un modello come quelli usati  per  l'espansione  del  nome  di
                      percorso. È applicato all'elenco dei possibili completamenti generati dalle
                      opzioni e dagli argomenti precedenti, e ogni completamento che  corrisponde
                      a  filterpat  viene rimosso dall'elenco. Un ! iniziale in filterpat nega il
                      modello; in questo caso ogni completamento che non concorda  con  filterpat
                      viene rimosso.

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

       compopt [-o opzione] [-DEI] [+o opzione] [nome]
              Modify  completion  options  for  each  name  according  to the options, or for the
              currently-executing completion if no names are supplied.  If no options are  given,
              display  the  completion  options  for  each  name  or the current completion.  The
              possible values of option are those valid for the complete builtin described above.
              The  -D  option indicates that other supplied options should apply to the “default”
              command completion; that is,  completion  attempted  on  a  command  for  which  no
              completion  has  previously  been  defined.   The  -E  option  indicates that other
              supplied options should apply to “empty” command completion;  that  is,  completion
              attempted  on  a  blank  line.  The -I option indicates that other supplied options
              should apply to completion on the initial non-assignment word on the line, or after
              a command delimiter such as ; or |, which is usually command name completion.

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

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

       declare [-aAfFgiIlnrtux] [-p] [nome[=valore] ...]
       typeset [-aAfFgiIlnrtux] [-p] [nome[=valore] ...]
              Declare  variables and/or give them attributes.  If no names are given then display
              the values of variables.  The -p option will display the attributes and  values  of
              each  name.  When -p is used with name arguments, additional options, other than -f
              and -F, are ignored.  When -p is supplied without name arguments, it  will  display
              the  attributes  and values of all variables having the attributes specified by the
              additional options.  If no other options are supplied with -p, declare will display
              the  attributes and values of all shell variables.  The -f option will restrict the
              display to shell functions.   The  -F  option  inhibits  the  display  of  function
              definitions;  only  the  function name and attributes are printed.  If the extdebug
              shell option is enabled using shopt, the source file name  and  line  number  where
              each  name  is  defined  are  displayed as well.  The -F option implies -f.  The -g
              option forces variables to be created or modified at the global  scope,  even  when
              declare is executed in a shell function.  It is ignored in all other cases.  The -I
              option causes local  variables  to  inherit  the  attributes  (except  the  nameref
              attribute)   and value of any existing variable with the same name at a surrounding
              scope.  If there is no existing variable, the local variable  is  initially  unset.
              The  following  options  can  be  used  to  restrict  output  to variables with the
              specified attribute or to give variables attributes:
              -a     Each name is an indexed array variable (see Arrays above).
              -A     Each name is an associative array variable (see Arrays above).
              -f     Usa solo nomi di funzioni.
              -i     The variable is treated as an integer; arithmetic evaluation (see ARITHMETIC
                     EVALUATION above) is performed when the variable is assigned a value.
              -l     Quando  alla  variabile  è  assegnato un valore, tutti i caratteri maiuscoli
                     sono convertiti in minuscolo. L'attributo upper-case è disabilitato.
              -n     Dà a ogni nome l'attributo nameref, rendendolo  un  riferimento  a  un'altra
                     variabile.   Quest'altra  variabile è definita dal valore di nome.   Tutti i
                     riferimenti, gli assegnamenti e le modifiche degli attributi a nome,  tranne
                     quelli  che  usano  o cambiano lo stesso attributo -n, sono effettuati sulla
                     variabile referenziata dal valore di nome.  L'attributo -n  non  può  essere
                     applicato alle variabili array.
              -r     Rende  nomi  accessibili  in  sola lettura. A questi nomi non possono quindi
                     essere assegnati valori da successive istruzioni di assegnamento, e i valori
                     assegnati non possono essere rimossi.
              -t     Dà  a ogni nome l'attributo trace. Le funzioni tracciate ereditano i segnali
                     intercettati DEBUG e RETURN dalla shell chiamante. L'attributo trace non  ha
                     un significato speciale per le variabili.
              -u     Quando  alla  variabile  è  assegnato un valore, tutti i caratteri minuscoli
                     sono convertiti in maiuscolo. L'attributo lower-case è disabilitato.
              -x     Marca nomi per l'esportazione ai successivi comandi attraverso l'ambiente.

              Usare `+' invece di `-' disattiva l'attributo, con l'eccezione che  +a   e  +A  non
              possono essere usati per eliminare una variabile array e +r non rimuove l'attributo
              di sola lettura. Quando usate in una funzione, declare e typeset rendono ogni  nome
              locale,  come  con il comando local, a meno che non venga fornita l'opzione -g.  Se
              un nome di variabile è seguito da =valore, il valore della variabile è impostato  a
              valore.   Il  valore  di  ritorno è 0 tranne quando viene incontrata un'opzione non
              valida, viene fatto un tentativo di definire una funzione usando ``-f foo=bar'', an
              attempt  is  made  to  assign a value to a readonly variable, an attempt is made to
              assign a value to an array variable without using the  compound  assignment  syntax
              (see Arrays above), one of the names is not a valid shell variable name, an attempt
              is made to turn off readonly status for a readonly variable, an attempt is made  to
              turn  off  array  status  for an array variable, or an attempt is made to display a
              non-existent function with -f.

       dirs [-clpv] [+n] [-n]
              Senza opzioni, mostra  la  lista  delle  directory  correntemente  memorizzate.  La
              visualizzazione  predefinita è su un singola riga coi nomi di directory separate da
              spazi. Le directory sono aggiunte alla lista con il comando pushd; il comando  popd
              rimuove  elementi  dalla  lista.  La directory corrente è sempre la prima directory
              nello stack.
              -c     Svuota lo stack delle directory cancellando tutti gli elementi.
              -l     Produce un elenco usando il percorso completo; il  formato  predefinito  per
                     l'elencazione usa un carattere tilde per indicare la home directory.
              -p     Stampa lo stack delle directory con un elemento per riga.
              -v     Stampa  lo stack delle directory con un elemento per riga,anteponendo a ogni
                     elemento il suo indice nello stack.
              +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.

              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 ... | pid ... ]
              Senza  opzioni, rimuove ogni jobspec dalla tabella dei job attivi. Se jobspec non è
              presente, e non viene fornita né l'opizone -a né l'opzione -r, viene usato  il  job
              corrente. Se viene data l'opzione -h, ogni jobspec non viene rimosso dalla tabella,
              ma è marcato in modo che SIGHUP non venga inviato al job  se  la  shell  riceve  un
              SIGHUP. Se non è 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 è  0,
              a meno che non si verifichi un errore di scrittura. Se è specificato -n, il newline
              finale è soppresso. Se è data l'opzione -e, viene abilitata  l'interpretazione  dei
              successivi  caratteri  preceduti  dal  carattere di protezione della barra inversa.
              L'opzione -E disabilita l'interpretazione di questi caratteri di protezione,  anche
              su  sistemi  dove  essi  sono  interpretati in modo predefinito. L'opzione di shell
              xpg_echo può essere usata per determinare  dinamicamente  se  echo  espande  questi
              caratteri  di protezione in modo predefinito oppure no. echo non interpreta -- come
              fine delle opzioni. echo interpreta le seguenti sequenze di protezione:
              \a     avviso (segnale acustico)
              \b     backspace
              \c     elimina ulteriore output
              \e
              \E     un carattere di escape
              \f     salto pagina
              \n     codice di fine riga (newline)
              \r     ritorno carrello
              \t     tabulazione orizzontale
              \v     tabulazione verticale
              \\     barra inversa
              \0nnn  il carattere a otto bit il cui valore è il valore ottale nnn (da zero a  tre
                     cifre ottali)
              \xHH   il  carattere a otto bit il cui valore è il valore esadecimale HH (una o due
                     cifre esadecimali)
              \uHHHH il carattere Unicode (ISO/IEC 10646) il cui valore è il  valore  esadecimale
                     HHHH (da una a quattro cifre esadecimali)
              \UHHHHHHHH
                     il  carattere  Unicode (ISO/IEC 10646) il cui valore è il valore esadecimale
                     HHHHHHHH (da una a otto cifre esadecimali)

       enable [-a] [-dnps] [-f nome-file] [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''.   The  -f
              option  means  to load the new builtin command name from shared object filename, on
              systems  that  support  dynamic  loading.   Bash  will  use  the   value   of   the
              BASH_LOADABLES_PATH  variable  as a colon-separated list of directories in which to
              search for filename.  The default is system-dependent.  The -d option will delete a
              builtin  previously  loaded  with -f.  If no name arguments are given, or if the -p
              option is supplied, a list of shell builtins is  printed.   With  no  other  option
              arguments,  the  list  consists  of all enabled shell builtins.  If -n is supplied,
              only disabled builtins are printed.  If -a is supplied, the list  printed  includes
              all  builtins,  with  an  indication  of  whether or not each is enabled.  If -s is
              supplied, the output is restricted to the POSIX special builtins.   If  no  options
              are  supplied  and  a name is not a shell builtin, enable will attempt to load name
              from a shared object named name, as if the command were ``enable  -f  name  name  .
              The  return  value  is  0 unless a name is not a shell builtin or there is an error
              loading a new builtin from a shared object.

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

       exec [-cl] [-a nome] [comando [argomenti]]
              Se  comando  è  specificato, esso sostituisce la shell. Nessun nuovo processo viene
              creato. Gli argomenti  diventano  gli  argomenti  per  comando.  Se  viene  fornita
              l'opzione  -l  la  shell  pone  un  trattino  all'inizio dell'argomento numero zero
              passato  a  comando.  Questo  è  quello  che  fa  login(1).  L'opzione  -c  provoca
              l'esecuzione  di  comando con un ambiente vuoto. Se viene fornita -a la shell passa
              nome come argomento numero zero del comando eseguito. Se  comando  non  può  essere
              eseguito per qualche ragione, una shell non interattiva termina, a meno che non sia
              abilitata l'opzione di shell execfail, nel qual caso  restituisce  insuccesso.  Una
              shell  interattiva  restituisce insuccesso se il file non può essere eseguito.  Una
              subshell esce incondizionatamente se exec fallisce. 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 [-fn] [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  nomi  di tutte le variabili esportate. L'opzione -n provoca la rimozione
              della proprietà di esportazione da ogni nome. Se un nome di variabile è seguito  da
              =parola,  il  valore della variabile è impostato a parola. export ritorna uno stato
              d'uscita di 0 tranne quando viene trovata un'opzione non valida, uno dei nomi non è
              un  nome valido di variabile di shell, o viene fornita l'opzione -f con un nome che
              non è il nome di una funzione.

       fc [-e nome-editor] [-lnr] [primo] [ultimo]
       fc -s [pat=rep] [cmd]
              The first form selects a range of commands from first to last from the history list
              and  displays  or edits and re-executes them.  First and last may be specified as a
              string (to locate the last command beginning with that string) or as a  number  (an
              index  into the history list, where a negative number is used as an offset from the
              current command number).  When listing, a first or last of 0 is  equivalent  to  -1
              and  -0  is equivalent to the current command (usually the fc command); otherwise 0
              is equivalent to -1 and -0 is invalid.  If last is not specified, it is set to  the
              current  command for listing (so that ``fc -l -10'' stampa gli ultimi 10 comandi) e
              a primo altrimenti. Se primo non è specificato è impostato  al  precedente  comando
              per la modifica e a -16 per l'elencazione.

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

              Nella seconda forma, comando è rieseguito dopo che ogni istanza di pat è sostituita
              da rep.  Comando è interpretato come primo.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 [arg ...]
              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 come  valori arg, 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 nome-file] [-dt] [nome]
              Ogni  volta  che  hash  viene  invocata,  il  percorso  completo del comando nome è
              determinato ricercando le directory in $PATH e  viene  memorizzato.  Ogni  nome  di
              percorso  precedentemente  memorizzato  viene perso. Se viene fornita l'opzione -p,
              non viene effettuata nessuna ricerca di percorso e  nome-file  è  usato  come  nome
              completo  del  comando. L'opzione -r fa sì che la shell dimentichi tutti i percorsi
              memorizzati. L'opzione -d fa sì che la shell dimentichi i percorsi  memorizzati  di
              ogni  nome.  Se viene fornita l'opzione -t è stampato il percorso completo al quale
              corrisponde ogni nome. Se vengono forniti argomenti multipli di  nome  con  -t,  il
              nome  viene  stampato prima del percorso completo indicizzato. L'opzione -l provoca
              la visualizzazione dell'output in un formato riutilizzabile come input.  Se  nessun
              argomento  è  dato, ed è fornito solo -l, è stampata l'informazione circa i comandi
              memorizzati. Lo stato di ritorno è 0 (vero) tranne quando  nome  è  irreperibile  o
              viene fornita un'opzione non valida.

       help [-dms] [modello]
              Mostra utili informazioni sui i comandi incorporati. Se modello è specificato, help
              fornisce un aiuto dettagliato su tutti i  comandi  che  corrispondono  al  modello;
              altrimenti  è  stampato  l'aiuto  per tutti i comandi incorporati e le strutture di
              controllo della shell.
              -d     Visualizza una breve descrizione di ogni modello
              -m     Visualizza la descrizione di ogni modello in un formato simile a manpage
              -s     Visualizza solo una breve sintassi d'uso per ogni modello

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

       history [n]
       history -c
       history -d scostamento
       history -d iniziofine
       history -anrw [nome-file]
       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 nome-file, questo è usato come
              nome del file di cronologia; altrimenti, è usato il valore di HISTFILE. Le opzioni,
              se fornite, hanno i seguenti significati:
              -c     Svuota l'elenco della cronologia eliminando tutti gli elementi.
              -d scostamento
                     Delete  the  history entry at position offset.  If offset is negative, it is
                     interpreted as relative to one greater than the last  history  position,  so
                     negative  indices count back from the end of the history, and an index of -1
                     refers to the current history -d command.
              -d inizio-fine
                     Delete the range  of  history  entries  between  positions  start  and  end,
                     inclusive.   Positive  and negative values for start and end are interpreted
                     as described above.
              -a     Accoda le “nuove” righe al file della cronologia. Queste  sono  righe  della
                     cronologia  inserite  dall'inizio  della  corrente  sessione di bash, ma non
                     ancora aggiunte 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  aggiunge  alla  fine  della
                     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.

              If  the  HISTTIMEFORMAT variable is set, the time stamp information associated with
              each history entry is written to the history file, marked with the history  comment
              character.  When the history file is read, lines beginning with the history comment
              character followed immediately by a digit are interpreted  as  timestamps  for  the
              following  history  entry.   The  return  value  is  0  unless an invalid option is
              encountered, an error occurs while reading or writing the history file, an  invalid
              offset or range is supplied as an argument to -d, or the history expansion supplied
              as an argument to -p fails.

       jobs [-lnprs] [ jobspec ... ]
       jobs -x comando [ args ... ]
              La prima forma elenca i job attivi. Le opzioni hanno i seguenti significati:
              -l     Elenca gli ID dei processi in aggiunta alle normali informazioni.
              -n     Mostra le informazioni solo sui job che  hanno  cambiato  stato  dall'ultima
                     notifica di stato mostrata all'utente.
              -p     Elenca solo l'ID di processo del principale job del gruppo di processo.
              -r     Mostra solo i job in esecuzione.
              -s     Mostra solo i 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|-L [sigspec | exit_status]
              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.   L'opzione  -L  è equivalente a -l. 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 ...]
              Each  arg  is  an  arithmetic expression to be evaluated (see ARITHMETIC EVALUATION
              above).  If the last arg evaluates to 0, let returns 1; 0 is returned otherwise.

       local [opzione] [nome[=valore] ... | - ]
              For each argument, a local variable named name is created, and assigned value.  The
              option  can be any of the options accepted by declare.  When local is used within a
              function, it causes the variable name to have a visible scope  restricted  to  that
              function and its children.  If name is -, the set of shell options is made local to
              the function in which local is invoked: shell options changed using the set builtin
              inside  the  function  are  restored  to  their  original  values when the function
              returns.  The restore is effected as if a series of set commands were  executed  to
              restore the values that were in place before the function.  With no operands, local
              writes a list of local variables to the standard output.  It is  an  error  to  use
              local  when  not  within  a  function.  The return status is 0 unless local is used
              outside a function, an invalid name is supplied, or name is a readonly variable.

       logout Termina una shell di login.

       mapfile [-d delim] [-n numero] [-O origine] [-s numero] [-t] [-u  fd]  [-C  callback]  [-c
       quantum] [array]
       readarray  [-d  delim] [-n numero] [-O origine] [-s numero] [-t] [-u fd] [-C callback] [-c
       quantum] [array]
              Legge righe dallo standard input  all'interno  della  variabile  array  indicizzata
              array,  o  dal  descrittore  di file fd se viene fornita l'opzione -u. La variabile
              MAPFILE  è  l'array  predefinito.  Le  opzioni,  se  fornite,  hanno  il   seguente
              significato:
              -d     The  first  character  of delim is used to terminate each input line, rather
                     than newline.  If delim is the empty string, mapfile will terminate  a  line
                     when it reads a NUL character.
              -n     Copia al massimo numero righe. Se numero è 0 vengono copiate tutte le righe.
              -O     Inizia assegnando array all'indice origine. L'indice predefinito è 0.
              -s     Ignora le prime numero righe lette.
              -t     Rimuove  il  delimitatore  (il  predefinito è "newline") finale da ogni riga
                     letta.
              -u     Legge le righe dal descrittore di file fd invece che dallo standard input.
              -C     Valuta callback ogni volta che vengono lette  quantum  righe.  L'opzione  -c
                     specifica quantum.
              -c     Specifica il numero di righe lette tra una chiamata e l'altra di callback.

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

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

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

       popd [-n] [+n] [-n]
              Removes entries from the  directory  stack.   The  elements  are  numbered  from  0
              starting  at  the  first directory listed by dirs.  With no arguments, popd removes
              the top directory from the stack, and changes to the new top directory.  Arguments,
              if supplied, have the following meanings:
              -n     Sopprime  il normale cambiamento di directory quando rimuove directory dallo
                     stack, ossia viene manipolato solo lo stack.
              +n     Removes the nth entry counting from the left of  the  list  shown  by  dirs,
                     starting  with  zero,  from  the stack.  For example: ``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.

              If the top element of the directory stack is modified, and the -n  option  was  not
              supplied,  popd  uses  the  cd builtin to change to the directory at the top of the
              stack.  If the cd fails, popd returns a non-zero value.

              Otherwise, popd returns false if an invalid option is  encountered,  the  directory
              stack is empty, or a non-existent directory stack entry is specified.

              If the popd command is successful, bash runs dirs to show the final contents of the
              directory stack, and the return status is 0.

       printf [-v var] formato [argomenti]
              Scrive gli argomenti formattati  sullo  standard  output  sotto  il  controllo  del
              formato. Con l'opzione -v l'output viene assegnato alla variabile var piuttosto che
              essere stampato sullo standard output.

              Il formato è una stringa di caratteri che contiene tre tipi di  oggetti:  caratteri
              semplici,  i  quali  sono  semplicemente copiati sullo standard output, sequenze di
              protezione dei caratteri, che sono convertite e copiate sullo  standard  output,  e
              specifiche  di  formato,  ognuna  delle  quali  provoca  la  stampa  dell'argomento
              seguente. Oltre alle specifiche di formato printf(1) standard, printf interpreta le
              seguenti estensioni:
              %b     fa  sì  che  printf  espanda sequenze di protezione tramite la barra inversa
                     nell'argomento corrispondente nello stesso modo di echo -e.
              %q     fa sì che printf stampi sull'output l'argomento corrispondente in un formato
                     riutilizzabile come input di shell.
              %Q     like  %q,  but applies any supplied precision to the argument before quoting
                     it.
              %(datefmt)T
                     causes printf to output the date-time string resulting from using datefmt as
                     a  format  string for strftime(3).  The corresponding argument is an integer
                     representing the number of seconds since the epoch.   Two  special  argument
                     values  may  be  used: -1 represents the current time, and -2 represents the
                     time the shell was invoked.  If no argument is specified, conversion behaves
                     as if -1 had been given.  This is an exception to the usual printf behavior.

              The  %b, %q, and %T directives all use the field width and precision arguments from
              the format specification and write that many bytes from (or use that wide  a  field
              for)  the  expanded  argument,  which  usually  contains  more  characters than the
              original.

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

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

       pushd [-n] [+n] [-n]
       pushd [-n] [dir]
              Adds  a  directory  to the top of the directory stack, or rotates the stack, making
              the new top of the stack the current working directory.  With no  arguments,  pushd
              exchanges  the  top  two  elements of the directory stack.  Arguments, if supplied,
              have the following meanings:
              -n     Sopprime il normale cambio di directory quando si ruotano  o  si  aggiungono
                     directory allo stack, cosicché viene manipolato solo lo stack.
              +n     Ruota  lo stack così che la n-esima directory (contando dalla sinistra della
                     lista mostrata da dirs, partendo da zero) vada in cima.
              -n     Ruota lo stack così che la n-esima directory (contando da destra della lista
                     mostrata da dirs, partendo da zero) vada in cima.
              dir    Adds dir to the directory stack at the top

              After  the  stack  has been modified, if the -n option was not supplied, pushd uses
              the cd builtin to change to the directory at the top  of  the  stack.   If  the  cd
              fails, pushd returns a non-zero value.

              Otherwise, if no arguments are supplied, pushd returns 0 unless the directory stack
              is empty.  When rotating the directory stack, pushd returns 0 unless the  directory
              stack is empty or a non-existent directory stack element is specified.

              If  the  pushd  command is successful, bash runs dirs to show the final contents of
              the directory stack.

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

       read  [-ers]  [-a  aname]  [-d  delim]  [-i testo] [-n nchars] [-N nchars] [-p prompt] [-t
       tempo_limite] [-u fd] [nome ...]
              One line is read from the standard input, or from the file descriptor  fd  supplied
              as  an  argument  to  the -u option, split into words as described above under Word
              Splitting, and the first word is assigned to the first name, the second word to the
              second  name,  and  so on.  If there are more words than names, the remaining words
              and their intervening delimiters are assigned to the last name.  If there are fewer
              words read from the input stream than names, the remaining names are assigned empty
              values.  The characters in IFS are used to split the line into words using the same
              rules  the  shell  uses  for expansion (described above under Word Splitting).  The
              backslash character (\) may be used to remove any  special  meaning  for  the  next
              character read and for line continuation.  Options, if supplied, have the following
              meanings:
              -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
                     The first character of delim is used to terminate  the  input  line,  rather
                     than newline.  If delim is the empty string, read will terminate a line when
                     it reads a NUL character.
              -e     If the standard input is coming from  a  terminal,  readline  (see  READLINE
                     above)  is  used to obtain the line.  Readline uses the current (or default,
                     if line editing was  not  previously  active)  editing  settings,  but  uses
                     readline's default filename completion.
              -i testo
                     Se  readline  è  in uso per leggere la riga, testo viene messo nel buffer di
                     modifica prima che inizi la correzione.
              -n nchars
                     read è considerata completata dopo aver letto  nchars  caratteri  invece  di
                     aspettare  una  riga di input completa, ma rispetta un delimitatore se prima
                     del delimitatore sono letti meno di nchars caratteri.
              -N nchars
                     read returns after reading exactly nchars characters rather than waiting for
                     a  complete  line  of  input,  unless  EOF is encountered or read times out.
                     Delimiter characters encountered in the input are not treated specially  and
                     do not cause read to return until nchars characters are read.  The result is
                     not split on the characters in IFS; the  intent  is  that  the  variable  is
                     assigned  exactly  the characters read (with the exception of backslash; see
                     the -r option below).
              -p prompt
                     Visualizza prompt sullo standard error, senza un newline  finale,  prima  di
                     tentare  di  leggere  qualsiasi  input. Il prompt è mostrato solo se l'input
                     proviene da un terminale.
              -r     La barra inversa non fa da carattere  di  protezione.  La  barra  inversa  è
                     considerata   come   parte   della   riga.   In   particolare,   una  coppia
                     barra_inversa-newline non può essere usata poi  come  una  continuazione  di
                     riga.
              -s     Modalità  silenziosa.  Se  l'input viene da un terminale i caratteri immessi
                     non vengono visualizzati sul terminale.
              -t tempo_limite
                     Cause read to time out and return failure if a complete line of input (or  a
                     specified  number  of  characters)   is  not  read  within  timeout seconds.
                     timeout may be a decimal number with  a  fractional  portion  following  the
                     decimal  point.  This option is only effective if read is reading input from
                     a terminal, pipe, or other special file; it has no effect when reading  from
                     regular  files.   If  read times out, read saves any partial input read into
                     the specified variable name.  If timeout is  0,  read  returns  immediately,
                     without trying to read any data.  The exit status is 0 if input is available
                     on the specified file descriptor, or the  read  will  return  EOF,  non-zero
                     otherwise.  The exit status is greater than 128 if the timeout is exceeded.
              -u fd  Legge l'input dal descrittore di file fd.

              If no names are supplied, the line read, without the ending delimiter but otherwise
              unmodified, is assigned to the variable REPLY.  The exit  status  is  zero,  unless
              end-of-file  is  encountered,  read  times out (in which case the status is greater
              than 128), a variable assignment error (such as assigning to a  readonly  variable)
              occurs, or an invalid file descriptor is supplied as the argument to -u.

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

       return [n]
              Causes  a  function  to  stop  executing and return the value specified by n to its
              caller.  If n is omitted, the return status is that of the last command executed in
              the  function body.  If return is executed by a trap handler, the last command used
              to determine the status is the last command executed before the trap  handler.   If
              return  is  executed  during  a  DEBUG trap, the last command used to determine the
              status is the last command executed by the trap handler before return was  invoked.
              If  return  is  used  outside a function, but during execution of a script by the .
              (source) command, it causes the shell to stop  executing  that  script  and  return
              either  n  or the exit status of the last command executed within the script as the
              exit status of the script.  If n  is  supplied,  the  return  value  is  its  least
              significant  8  bits.   The  return  status  is  non-zero  if  return is supplied a
              non-numeric argument, or is used outside a function and not during execution  of  a
              script  by  .  or  source.  Any command associated with the RETURN trap is executed
              before execution resumes after the function or script.

       set [-abefhkmnptuvxBCEHPT] [-o option-name] [--] [-] [arg ...]
       set [+abefhkmnptuvxBCEHPT] [+o option-name] [--] [-] [arg ...]
              Without options, display the name and value of each shell variable in a format that
              can  be  reused  as  input  for  setting  or resetting the currently-set variables.
              Read-only variables cannot be reset.  In  posix  mode,  only  shell  variables  are
              listed.   The  output  is sorted according to the current locale.  When options are
              specified, they set or unset  shell  attributes.   Any  arguments  remaining  after
              option  processing  are  treated  as  values  for the positional parameters and are
              assigned, in order, to $1, $2, ... $n.  Options, if specified, have  the  following
              meanings:
              -a      Each  variable  or function that is created or modified is given the export
                      attribute and marked for export to the environment of subsequent commands.
              -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      Exit immediately if a pipeline  (which  may  consist  of  a  single  simple
                      command),  a  list,  or a compound command (see SHELL GRAMMAR above), exits
                      with a non-zero status.  The shell does not exit if the command that  fails
                      is part of the command list immediately following a while or until keyword,
                      part of the test following the if or  elif  reserved  words,  part  of  any
                      command  executed in a && or || list except the command following the final
                      && or ||, any command in a pipeline but  the  last,  or  if  the  command's
                      return  value is being inverted with !.  If a compound command other than a
                      subshell returns a non-zero status because a command failed  while  -e  was
                      being ignored, the shell does not exit.  A trap on ERR, if set, is executed
                      before the shell exits.  This option applies to the shell  environment  and
                      each  subshell  environment  separately  (see COMMAND EXECUTION ENVIRONMENT
                      above), and may cause subshells to exit before executing all  the  commands
                      in the subshell.

                      e  un comando composto o una funzione di shell è eseguito in un contesto in
                      cui -e è ignorato, nessuno dei comandi eseguiti all'interno di  un  comando
                      composto o nel corpo di una funzione verrà influenzato dall'impostazione di
                      -e, anche se -e è impostato e un comando ritorna uno  stato  di  insucesso.
                      Se  un  comando  composto  o  una  funzione  di  shell  imposta  -e durante
                      l'esecuzione in un contesto in cui -e è ignorato, quelle  impostazioni  non
                      avranno alcun effetto finché il comando composto o il comando contenente la
                      chiamata di funzione sia completato.
              -f      Disabilita l'espansione di percorso.
              -h      Ricorda  la  posizione  dei  comandi  man  mano  che  sono  ritrovati   per
                      l'esecuzione. Questa è abilitata in modo predefinito.
              -k      Tutti  gli  argomenti  nella forma di istruzioni di assegnamento sono posti
                      nell'ambiente per un comando, non solo quelli che  precedono  il  nome  del
                      comando stesso.
              -m      Monitor  mode.   Job  control is enabled.  This option is on by default for
                      interactive shells on systems that support it (see JOB CONTROL above).  All
                      processes  run  in  a  separate  process  group.   When  a  background  job
                      completes, the shell prints a line containing its exit status.
              -n      Legge i comandi ma non li esegue. Questo può essere usato  per  controllare
                      uno  script  di  shell  per errori di sintassi. Questo viene ignorato se la
                      shell è interattiva.
              -o nome-opzione
                      Il nome-opzione può essere uno dei seguenti:
                      allexport
                              Lo stesso di -a.
                      braceexpand
                              Lo stesso di -B.
                      emacs   Usa una interfaccia di modifica della  riga  di  comando  in  stile
                              emacs.  Questo  è  abilitato  in modo predefinito quando la shell è
                              interattiva, a meno che la shell  non  sia  avviata  con  l'opzione
                              --noediting.  Questo inoltre influisce sull'interfaccia di modifica
                              usata per read -e.
                      errexit Lo stesso di -e.
                      errtrace
                              Lo stesso di -E.
                      functrace
                              Lo stesso di -T.
                      hashall Lo stesso di -h.
                      histexpand
                              Lo stesso di -H.
                      history Enable command history, as described  above  under  HISTORY.   This
                              option is on by default in interactive shells.
                      ignoreeof
                              L'effetto  è  lo  stesso come se fosse stato eseguito il comando di
                              shell ``IGNOREEOF=10''  had  been  executed  (see  Shell  Variables
                              above).
                      keyword Lo stesso di -k.
                      monitor Lo stesso di -m.
                      noclobber
                              Lo stesso di -C.
                      noexec  Lo stesso di -n.
                      noglob  Lo stesso di -f.
                      nolog   Attualmente ignorato.
                      notify  Lo stesso di -b.
                      nounset Lo stesso di -u.
                      onecmd  Lo stesso di -t.
                      physical
                              Lo stesso di -P.
                      pipefail
                              Se  impostato,  il  valore  di  ritorno di una pipeline è il valore
                              dell'ultimo comando (quello più a destra) che esce  con  uno  stato
                              d'uscita  diverso da zero, o zero se tutti i comandi nella pipeline
                              escono con successo. Come comportamento predefinito, questa opzione
                              è disabilitata.
                      posix   Change  the  behavior  of  bash where the default operation differs
                              from the POSIX standard to match the standard  (posix  mode).   See
                              SEE ALSO below for a reference to a document that details how posix
                              mode affects bash's behavior.
                      privileged
                              Lo stesso di -p.
                      verbose Lo stesso di -v.
                      vi      Usa un'interfaccia di modifica della riga di comando in  stile  vi.
                              Questo  inoltre  influisce  sull'interfaccia  di modifica usata per
                              read -e.
                      xtrace  Lo stesso di -x.
                      Se -o è fornito con nessun  nome-opzione,  sono  stampati  i  valori  delle
                      opzioni  correnti.  Se  +o  è fornito con nessun nome-opzione, una serie di
                      comandi set  per  ricreare  le  impostazioni  dell'opzione  corrente  viene
                      visualizzata sullo standard output.
              -p      Attiva  il  modo  privilegiato. In questo modo, i file $ENV e $BASH_ENV non
                      vengono elaborati, le funzioni di shell non sono ereditate dall'ambiente  e
                      le  variabili  SHELLOPTS,  BASHOPTS,  CDPATH e GLOBIGNORE se appaiono in un
                      ambiente, vengono ignorate.  Se  la  shell  è  avviata  con  l'id  (gruppo)
                      effettivo  dell'utente  non uguale all'id (gruppo) reale dell'utente, e non
                      viene fornita l'opzione -p, queste azioni vengono eseguite e l'id effettivo
                      dell'utente   è  impostato  all'id  reale  dell'utente.  Se  viene  fornita
                      l'opzione -p all'avvio,  l'id  effettivo  dell'utente  non  è  reimpostato.
                      Disattivare  questa  opzione  fa  sì che gli id effettivi dell'utente e del
                      gruppo siano impostati agli id reali dell'utente e del gruppo.
              -r      Enable restricted shell mode.  This option cannot be unset once it has been
                      set.
              -t      Esce dopo aver letto ed eseguito un comando.
              -u      Treat  unset variables and parameters other than the special parameters "@"
                      and "*", or array variables subscripted with "@" or "*", as an  error  when
                      performing  parameter  expansion.   If  expansion  is attempted on an unset
                      variable or parameter, the shell prints  an  error  message,  and,  if  not
                      interactive, exits with a non-zero status.
              -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      The shell performs brace expansion (see Brace Expansion above).  This is on
                      by 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
                      in modo predefinito quando la shell è interattiva.
              -P      Se impostato, non risolve i collegamenti simbolici  quando  esegue  comandi
                      come  cd  che  cambiano  la directory di lavoro corrente. È invece usata la
                      struttura di directory fisica. Come comportamento predefinito,  bash  segue
                      la  successione  logica  delle  directory  quando  si  eseguono comandi che
                      cambiano la directory corrente.
              -T      Se impostata, i comandi  sui  segnali  intercettati  DEBUG  e  RETURN  sono
                      ereditati  dalle  funzioni  di  shell,  dalle sostituzioni di comando e dai
                      comandi eseguiti in un ambiente di subshell. I segnali intercettati DEBUG e
                      RETURN normalmente non vengono ereditati in questi casi.
              --      Se  nessun  argomento  segue questa opzione, allora i parametri posizionali
                      sono assenti. Altrimenti, i parametri posizionali sono impostati agli  arg,
                      anche se alcuni di loro iniziano con un -.
              -       Segnala  la  fine  delle  opzioni,  e fa sì che tutti i rimanenti arg siano
                      assegnati ai parametri posizionali. Le opzioni -x e -v sono disattivate. Se
                      non vi è alcun arg, i parametri posizionali rimangono inalterati.

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

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

       shopt [-pqsu] [-o] [nome-opzione ...]
              Attiva/disattiva i valori  delle  impostazioni  che  controllano  il  comportamento
              opzionale della shell. Le impostazioni possono essere o quelle elencate sotto o, se
              viene  usata  l'opzione  -o,  quelle  disponibili  con  l'opzione  -o  al   comando
              incorporato  set.  Senza  opzioni,  o con l'opzione -p, viene mostrata una lista di
              tutte le opzioni impostabili, con una indicazione se ognuna è impostata  o  no;  se
              vengono  forniti  nomi-opzioni, l'output è ristretto a queste opzioni. 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, shopt mostra solo
              quelle  opzioni  che  sono,  rispettivamente,  attivate  o  non  attivate.  Se  non
              diversamente  indicato  le  opzioni  shopt sono disabilitate (non attivate) in modo
              predefinito.

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

              L'elenco delle opzioni di shopt è:

              assoc_expand_once
                      If  set,  the  shell  suppresses  multiple  evaluation of associative array
                      subscripts  during  arithmetic  expression  evaluation,   while   executing
                      builtins  that  can  perform  variable  assignments,  and  while  executing
                      builtins that perform array dereferencing.
              autocd  Se impostato, viene eseguito un nome di  comando  che  è  il  nome  di  una
                      directory  come  se fosse un argomento del comando cd. Questa opzione viene
                      usata solo dalle shell interattive.
              cdable_vars
                      Se impostata, un argomento al  comando  incorporato  cd  che  non  sia  una
                      directory  è  considerato  come il nome di una variabile il cui valore è la
                      directory verso cui cambiare.
              cdspell Se  impostata,  vengono  corretti  errori  minori  nell'ortografia  di   un
                      componente  di  directory  in  un  comando  cd.  Gli  errori ricercati sono
                      caratteri invertiti, mancanza di un carattere e un  carattere  in  più.  Se
                      viene  trovata  una  correzione  il  nome-file corretto viene stampato e il
                      comando prosegue. Quest'opzione è usata solo dalle shell interattive.
              checkhash
                      Se impostata, bash controlla che un comando trovato  in  una  tabella  hash
                      esista  prima  di  tentarne  l'esecuzione. Se un comando la cui posizione è
                      disponibile in un  elemento  della  tabella  hash  non  esiste  più,  viene
                      effettuata una normale ricerca di percorso.
              checkjobs
                      If  set,  bash  lists  the  status  of  any stopped and running jobs before
                      exiting an interactive shell.  If any jobs are  running,  this  causes  the
                      exit to be deferred until a second exit is attempted without an intervening
                      command (see JOB CONTROL above).  The shell always postpones exiting if any
                      jobs are stopped.
              checkwinsize
                      Se impostata, bash controlla la dimensione della finestra dopo ogni comando
                      esterno (non incorporato) e, se necessario, aggiorna i valori  di  LINES  e
                      COLUMNS.  Quest'opzione è abilitata in modo predefinito.
              cmdhist If  set,  bash attempts to save all lines of a multiple-line command in the
                      same history entry.  This allows easy re-editing  of  multi-line  commands.
                      This  option  is  enabled  by  default,  but  only has an effect if command
                      history is enabled, as described above under HISTORY.
              compat31
              compat32
              compat40
              compat41
              compat42
              compat43
              compat44
              compat50
                      These  control  aspects  of  the  shell's  compatibility  mode  (see  SHELL
                      COMPATIBILITY MODE below).

              complete_fullquote
                      Se  impostata, bash quota tutti i metacaratteri di shell nei nomi-file e di
                      directory quando effettua il completamento.   Se  non  è  impostata,   bash
                      rimuove  i metacaratteri come il segno del dollaro dal set di caratteri che
                      saranno  quotati  nei  nomi-file  completati  quando  questi  metacaratteri
                      appaiono  in  riferimenti  a variabili di shell nelle parole da completare.
                      Questo vuol dire che i segni del dollaro  nei  nomi  di  variabile  che  si
                      espandono  a  directory non verranno quotati; comunque, non saranno quotati
                      neanche i segni del dollaro che appaiono nei nomi-file.   Questo  è  attivo
                      solo  quando  bash usa le barre inverse per quotare i nomi-file completati.
                      Questa variabile è impostata in modo predefinito, che  è  il  comportamento
                      predefinito di bash nelle versioni fino alla 4.2.

              direxpand
                      Se  impostata,  bash  sostituisce  i  nomi  di  directory  con  i risultati
                      dell'espansione di parola mentre effettua  il  completamento  del  nome  di
                      file.   Questo  cambia  i contenuti del buffer di modifica di readline.  Se
                      non è impostata, bash tenta di conservare ciò che ha scritto l'utente.

              dirspell
                      Se  impostata,  bash  tenta  la  correzione  dell'ortografia  sui  nomi  di
                      directory  durante  il  completamento  di  parola  se  il nome di directory
                      fornito inizialmente non esiste.

              dotglob Se impostata, bash  include  i  nomi-file  che  iniziano  con  un  `.'  nel
                      risultato  dell'espansione  del  percorso.  I nomi-file  “.” e “..”  devono
                      essere sempre confrontati esplicitamente, anche se dotglob è impostato.

              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
                      If set, aliases are expanded as described above under ALIASES.  This option
                      is enabled by default for interactive shells.

              extdebug
                      Se  impostata  all'invocazione  della  shell,  o  in un file di avvio della
                      shell, provvede all'esecuizone del "debugger profile" prima  che  la  shell
                      venga  avviata,  allo stesso modo dell'opzione --debugger.Se impostata dopo
                      l'invocazione, 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), la shell simula una chiamata a return.

                      4.     BASH_ARGC  and  BASH_ARGV  are  updated  as   described   in   their
                             descriptions above).

                      5.     Il tracciamento delle funzioni è abilitato: sostituzione di comando,
                             funzioni di shell, e subshell invocate con ( comando ) ereditano  le
                             intercettazione di segnale DEBUG e RETURN.

                      6.     Il  tracciamento  degli errori è abilitato: sostituzione di comando,
                             funzioni di shell, e subshell invocate con ( comando ) ereditano  le
                             intercettazione di segnale ERR.

              extglob If  set,  the  extended  pattern  matching  features  described above under
                      Pathname Expansion are enabled.

              extquote
                      Se impostato, la quotatura $'string' e $"string" è  effettuata  all'interno
                      delle  espansioni di ${parametro} racchiuse tra virgolette. Quest'opzione è
                      abilitata in modo predefinito.

              failglob
                      Se impostata, i modelli che  non  generano  nomi  validi  di  file  durante
                      l'espansione del percorso danno come risultato un errore di espansione.

              force_fignore
                      If set, the suffixes specified by the FIGNORE shell variable cause words to
                      be ignored when performing word completion even if the  ignored  words  are
                      the only possible completions.  See SHELL VARIABLES above for a description
                      of FIGNORE.  This option is enabled by default.

              globasciiranges
                      If set, range expressions used in pattern matching bracket expressions (see
                      Pattern  Matching  above)  behave  as  if  in the traditional C locale when
                      performing comparisons.  That is, the current locale's  collating  sequence
                      is  not  taken  into  account,  so  b will not collate between A and B, and
                      upper-case and lower-case ASCII characters will collate together.

              globskipdots
                      If set, pathname expansion will never match the  filenames  “.”  and  “..”,
                      even if the pattern begins with a “.”.  This option is enabled by default.

              globstar
                      Se  impostata, il modello ** usato in un contesto di espansione del nome di
                      percorso trova tutti i file e zero o più  directory  e  sottodirectory  che
                      soddisfano  i  criteri  di ricerca. Se il modello è seguito da una /, trova
                      solo le directory e sottodirectory che soddisfano i criteri di ricerca.

              gnu_errfmt
                      Se impostata, i messaggi di errore della shell vengono scritti nel  formato
                      GNU standard dei messaggi di errore.

              histappend
                      Se  impostata,  l'elenco della cronologia è accodato al file indicato dalla
                      variabile HISTFILE all'uscita della shell, invece che  sostituire  il  file
                      preesistente.

              histreedit
                      Se  impostata, e readline è in uso, viene data l'opportunità a un utente di
                      ripetere una sostituzione della cronologia che non ha avuto successo.

              histverify
                      Se impostata, e readline è in uso, i  risultati  della  sostituzione  della
                      cronologia  non  sono  immediatamente passati all'analizzatore della shell.
                      Invece, la riga risultante viene caricata nel buffer di modifica  readline,
                      permettendo ulteriori modifiche.

              hostcomplete
                      If  set,  and readline is being used, bash will attempt to perform hostname
                      completion when a word containing a @ is being  completed  (see  Completing
                      under READLINE above).  This is enabled by default.

              huponexit
                      Se  impostata,  bash  invia SIGHUP a tutti i job all'uscita di una shell di
                      login interattiva.

              inherit_errexit
                      If set, command substitution inherits the  value  of  the  errexit  option,
                      instead  of  unsetting  it  in  the  subshell  environment.  This option is
                      enabled when posix mode is enabled.

              interactive_comments
                      If set, allow a word beginning with # to cause that word and all  remaining
                      characters on that line to be ignored in an interactive shell (see COMMENTS
                      above).  This option is enabled by default.

              lastpipe
                      Se impostata, e job control non è attivo, la shell esegue l'ultimo  comando
                      di una pipeline non eseguita in background nell'ambiente di shell corrente.

              lithist Se  impostata,  e  l'opzione  cmdhist è abilitata, i comandi multiriga sono
                      salvati nella cronologia includendo i newline, piuttosto  che  usando  come
                      separatori il punto e virgola, dove possibile.

              localvar_inherit
                      If  set,  local variables inherit the value and attributes of a variable of
                      the same name that exists at a previous  scope  before  any  new  value  is
                      assigned.  The nameref attribute is not inherited.

              localvar_unset
                      If  set, calling unset on local variables in previous function scopes marks
                      them so subsequent lookups find them unset  until  that  function  returns.
                      This  is  identical  to  the  behavior  of unsetting local variables at the
                      current function scope.

              login_shell
                      The shell sets this  option  if  it  is  started  as  a  login  shell  (see
                      INVOCATION above).  The value may not be changed.

              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
                      If   set,  bash  matches  filenames  in  a  case-insensitive  fashion  when
                      performing pathname expansion (see Pathname Expansion above).

              nocasematch
                      Se impostata, bash confronta modelli senza distinguere le  maiuscole  dalle
                      minuscole  quando  ricerca  corrispondenze durante l'esecuzione dei comandi
                      condizionali case o  [[,  quando  effettua  espansioni  di  parola  in  una
                      sostituzione di modello, o quando filtra possibili completamenti come parte
                      di un completamento programmabile.

              noexpand_translation
                      If set, bash encloses the translated results of $"..."  quoting  in  single
                      quotes instead of double quotes.  If the string is not translated, this has
                      no effect.

              nullglob
                      If set, bash allows patterns which match no files (see  Pathname  Expansion
                      above) to expand to a null string, rather than themselves.

              patsub_replacement
                      If  set, bash expands occurrences of & in the replacement string of pattern
                      substitution to the  text  matched  by  the  pattern,  as  described  under
                      Parameter Expansion above.  This option is enabled by default.

              progcomp
                      If set, the programmable completion facilities (see Programmable Completion
                      above) are enabled.  This option is enabled by default.

              progcomp_alias
                      If set, and programmable completion is enabled, bash treats a command  name
                      that  doesn't  have  any completions as a possible alias and attempts alias
                      expansion. If it has an alias, bash attempts programmable completion  using
                      the command word resulting from the expanded alias.

              promptvars
                      If  set,  prompt strings undergo parameter expansion, command substitution,
                      arithmetic expansion, and quote removal after being expanded  as  described
                      in PROMPTING above.  This option is enabled by default.

              restricted_shell
                      The  shell  sets  this  option  if  it  is  started in restricted mode (see
                      RESTRICTED SHELL below).  The value may not be changed.  This is not  reset
                      when the startup files are executed, allowing the startup files to discover
                      whether or not a shell is restricted.

              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
                      If set, the . (source) builtin uses the value of PATH to find the directory
                      containing  the  file  supplied  as an argument.  This option is enabled by
                      default.

              varredir_close
                      If set, the shell automatically closes file descriptors assigned using  the
                      {varname}  redirection  syntax  (see  REDIRECTION above) instead of leaving
                      them open when the command completes.

              xpg_echo
                      Se impostata, il comando incorporato echo espande  sequenze  di  protezione
                      tramite la barra inversa in modo predefinito.

       suspend [-f]
              Suspend  the  execution  of this shell until it receives a SIGCONT signal.  A login
              shell, or a shell without job control enabled, cannot be suspended; the  -f  option
              can  be  used  to  override  this and force the suspension.  The return status is 0
              unless the shell is a login shell or job control is  not  enabled  and  -f  is  not
              supplied.

       test expr
       [ expr ]
              Return  a  status  of  0  (true)  or  1  (false) depending on the evaluation of the
              conditional expression  expr.   Each  operator  and  operand  must  be  a  separate
              argument.   Expressions  are  composed  of  the  primaries  described  above  under
              CONDITIONAL EXPRESSIONS.  test does not accept any options, nor does it accept  and
              ignore an argument of -- as signifying the end of options.

              Le  espressioni  possono  essere combinate usando i seguenti operatori, elencati in
              ordine decrescente di precedenza. La valutazione dipende dal numero  di  argomenti;
              si  veda  più avanti. La precedenza degli operatori è usata quando ci sono cinque o
              più argomenti.
              ! expr Vero se expr è falso.
              ( expr )
                     Ritorna il valore di expr. Questo può essere usato per modificare la normale
                     precedenza degli operatori.
              expr1 -a expr2
                     Vero se sia expr1 che expr2 sono vere.
              expr1 -o expr2
                     Vero se o expr1 o expr2 è vera.

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

              0 argomenti
                     L'espressione è falsa.
              1 argomento
                     L'espressione è vera se e solo se l'argomento non è nullo.
              2 argomenti
                     If the first argument is !, the expression is true if and only if the second
                     argument  is  null.   If  the first argument is one of the unary conditional
                     operators listed above under CONDITIONAL EXPRESSIONS, the expression is true
                     if  the  unary  test  is  true.   If the first argument is not a valid unary
                     conditional operator, the expression is false.
              3 argomenti
                     The following conditions are applied in the order  listed.   If  the  second
                     argument  is  one  of  the  binary  conditional operators listed above under
                     CONDITIONAL EXPRESSIONS, the result of the expression is the result  of  the
                     binary  test using the first and third arguments as operands.  The -a and -o
                     operators are considered binary operators when there  are  three  arguments.
                     If  the  first  argument is !, the value is the negation of the two-argument
                     test using the second and third arguments.  If the first argument is exactly
                     (  and  the third argument is exactly ), the result is the one-argument test
                     of the second argument.  Otherwise, the expression is false.
              4 argomenti
                     The following conditions are applied in the  order  listed.   If  the  first
                     argument  is  !, the result is the negation of the three-argument expression
                     composed of the remaining arguments.  the two-argument test using the second
                     and  third  arguments.   If  the  first argument is exactly ( and the fourth
                     argument is exactly ), the result is the two-argument test of the second and
                     third   arguments.   Otherwise,  the  expression  is  parsed  and  evaluated
                     according to precedence using the rules listed above.
              5 o più argomenti
                     L'espressione è analizzata e valutata secondo le precedenze usando le regole
                     elencate sopra.

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

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

       trap [-lp] [[arg] sigspec ...]
              Il  comando  arg  dev'essere  letto e eseguito quando la shell riceve il segnale(i)
              sigspec. Se arg è assente (e c'è un singolo sigspec) o -, ogni segnale  specificato
              è  riportato  alla  sua  configurazione  originale  (il valore che aveva al momento
              dell'ingresso nella shell). Se arg è la stringa nulla  il  segnale  specificato  da
              ogni  sigspec  è  ignorato  dalla shell e dai comandi che essa invoca. Se arg non è
              presente e -p è stato fornito, allora  i  comandi  di  intercettazione  di  segnale
              associati a ogni sigspec vengono visualizzati. Se non viene fornito alcun argomento
              o se è dato solo -p, trap stampa la lista dei comandi  associati  a  ogni  segnale.
              L'opzione  -l  fa  sì che la shell stampi una lista di nomi di segnale e i numeri a
              loro corrispondenti. Ogni sigspec è o un nome di segnale definito in <signal.h>,  o
              un numero di segnale. I nomi di segnale possono essere scritti sia in minuscolo che
              in maiuscolo e il prefisso SIG è opzionale.

              If a sigspec is EXIT (0) the command arg is executed on exit from the shell.  If  a
              sigspec  is  DEBUG,  the  command  arg is executed before every simple command, for
              command, case command, select command, every arithmetic for command, and before the
              first command executes in a shell function (see SHELL GRAMMAR above).  Refer to the
              description of the extdebug option to the shopt builtin for details of  its  effect
              on the DEBUG trap.  If a sigspec is RETURN, the command arg is executed each time a
              shell function or a  script  executed  with  the  .  or  source  builtins  finishes
              executing.

              If  a  sigspec  is  ERR, the command arg is executed whenever a pipeline (which may
              consist of a single simple command), a  list,  or  a  compound  command  returns  a
              non-zero  exit  status,  subject  to the following conditions.  The ERR trap is not
              executed if the failed command is part of the command list immediately following  a
              while  or  until  keyword,  part  of the test in an if statement, part of a command
              executed in a && or || list except the command following the final &&  or  ||,  any
              command  in  a  pipeline  but  the  last, or if the command's return value is being
              inverted using !.  These are the same conditions obeyed by the errexit (-e) option.

              I segnali  ignorati  al  momento  dell'ingresso  della  shell  non  possono  essere
              intercettati  o  resettati.  I  segnali intercettati non ignorati sono riportati al
              loro valore originale in una subshell o in un ambiente  di  subshell  quando  ne  è
              stato  creato  uno.  Lo  stato  di  ritorno  è  falso  se  un sigspec non è valido;
              altrimenti trap ritorna 0 (vero).

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

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

              Se limite è dato, e non viene usata l'opzione -a, limite  è il nuovo  valore  della
              risorsa  specificata.   Se nessuna opzione è data, si considera impostata l'opzione
              -f.  I valori sono in multipli di 1024 byte, tranne  che per -t, che è in  secondi,
              -R,  che  è in microsecondi;-p, che è in unità di blocchi da 512 byte; -P, -T, -b ,
              -k, -n e -u, che sono numeri puri e , quando si è in modalità posix, -c e  -f,  che
              sono  in  multipli  di  512  byte.  Lo  stato  di  ritorno  è 0 tranne quando viene
              incontrata un'opzione o un argomento non valido, o  avvenga  un  errore  mentre  si
              imposta un nuovo limite.

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

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

       unset [-fv] [-n] [nome ...]
              For each name, remove the corresponding variable or function.  If the -v option  is
              given,  each  name  refers  to  a  shell  variable,  and  that variable is removed.
              Read-only variables may not be unset.  If -f is specified, each name  refers  to  a
              shell  function,  and  the  function  definition  is  removed.  If the -n option is
              supplied, and name is a variable with the nameref attribute,  name  will  be  unset
              rather  than  the  variable  it  references.   -n has no effect if the -f option is
              supplied.  If no options are supplied, each name refers to a variable; if there  is
              no  variable by that name, a function with that name, if any, is unset.  Each unset
              variable or function is removed from the environment passed to subsequent commands.
              If   any  of  BASH_ALIASES,  BASH_ARGV0,  BASH_CMDS,  BASH_COMMAND,  BASH_SUBSHELL,
              BASHPID, COMP_WORDBREAKS, DIRSTACK, EPOCHREALTIME, EPOCHSECONDS, FUNCNAME,  GROUPS,
              HISTCMD,  LINENO,  RANDOM,  SECONDS,  or SRANDOM are unset, they lose their special
              properties, even if they are subsequently reset.  The exit status is true unless  a
              name is readonly or may not be unset.

       wait [-fn] [-p varname] [id ...]
              Wait  for  each specified child process and return its termination status.  Each id
              may be a process ID or a job specification; if a job spec is given,  all  processes
              in  that  job's  pipeline  are  waited for.  If id is not given, wait waits for all
              running background jobs and the last-executed process substitution, if its  process
              id is the same as $!, and the return status is zero.  If the -n option is supplied,
              wait waits for a single job from the list of ids or, if no ids  are  supplied,  any
              job, to complete and returns its exit status.  If none of the supplied arguments is
              a child of the shell, or if  no  arguments  are  supplied  and  the  shell  has  no
              unwaited-for  children,  the exit status is 127.  If the -p option is supplied, the
              process or job identifier of the job for which  the  exit  status  is  returned  is
              assigned  to  the variable varname named by the option argument.  The variable will
              be unset initially, before any assignment.  This is useful only when the -n  option
              is  supplied.  Supplying the -f option, when job control is enabled, forces wait to
              wait for id to terminate before returning its status, instead of returning when  it
              changes  status.   If id specifies a non-existent process or job, the return status
              is 127.  If wait is interrupted by a signal, the return status will be greater than
              128,  as  described  under SIGNALS above.  Otherwise, the return status is the exit
              status of the last process or job waited for.

MODALITÀ COMPATIBILE DELLA SHELL

       Bash-4.0 introduced the concept of a shell compatibility level,  specified  as  a  set  of
       options  to the shopt builtin ( compat31, compat32, compat40, compat41, and so on).  There
       is only one current compatibility  level  --  each  option  is  mutually  exclusive.   The
       compatibility  level  is intended to allow users to select behavior from previous versions
       that is incompatible with newer  versions  while  they  migrate  scripts  to  use  current
       features and behavior. It's intended to be a temporary solution.

       This  section  does  not mention behavior that is standard for a particular version (e.g.,
       setting compat32 means that quoting the rhs of the regexp matching operator quotes special
       regexp  characters  in  the  word,  which  is  default behavior in bash-3.2 and subsequent
       versions).

       If a user enables, say, compat32, it may affect the behavior of other compatibility levels
       up  to and including the current compatibility level.  The idea is that each compatibility
       level controls behavior that changed in that version of bash, but that behavior  may  have
       been  present  in  earlier  versions.   For  instance,  the  change  to  use  locale-based
       comparisons with the [[ command came in bash-4.1, and earlier  versions  used  ASCII-based
       comparisons,  so  enabling  compat32  will  enable  ASCII-based comparisons as well.  That
       granularity may not be sufficient for all uses,  and  as  a  result  users  should  employ
       compatibility  levels  carefully.  Read the documentation for a particular feature to find
       out the current behavior.

       Bash-4.3 introduced a new  shell  variable:  BASH_COMPAT.   The  value  assigned  to  this
       variable  (a  decimal version number like 4.2, or an integer corresponding to the compatNN
       option, like 42) determines the compatibility level.

       Starting  with  bash-4.4,  Bash  has  begun  deprecating   older   compatibility   levels.
       Eventually, the options will be removed in favor of BASH_COMPAT.

       Bash-5.0  is  the final version for which there will be an individual shopt option for the
       previous version. Users should use BASH_COMPAT on bash-5.0 and later versions.

       The following table describes the behavior changes controlled by each compatibility  level
       setting.   The compatNN tag is used as shorthand for setting the compatibility level to NN
       using one of the following mechanisms.  For versions prior to bash-5.0, the  compatibility
       level  may  be  set using the corresponding compatNN shopt option.  For bash-4.3 and later
       versions, the BASH_COMPAT variable is preferred, and it is required for bash-5.1 and later
       versions.

       compat31
              •      quoting  the  rhs  of the [[ command's regexp matching operator (=~)  has no
                     special effect

       compat32
              •      interrupting a command list such as "a ; b ; c" causes the execution of  the
                     next  command in the list (in bash-4.0 and later versions, the shell acts as
                     if it received the interrupt, so interrupting one command in a  list  aborts
                     the execution of the entire list)

       compat40
              •      gli  operatori  <  e  >  del  comando  condizionale  [[  non  considerano la
                     localizzazione corrente nel confronto fra stringhe, ma  usano  l'ordinamento
                     ASCII. Le versioni di bash precedenti a bash-4.1 usano la collazione ASCII e
                     strcmp(3); bash-4.1 e versioni successive usano la  sequenza  di  collazione
                     della localizzazione corrente e strcoll(3).

       compat41
              •      in  posix mode, time may be followed by options and still be recognized as a
                     reserved word (this is POSIX interpretation 267)
              •      in posix mode, the parser requires that an  even  number  of  single  quotes
                     occur  in the word portion of a double-quoted parameter expansion and treats
                     them specially, so that characters within the single quotes  are  considered
                     quoted (this is POSIX interpretation 221)

       compat42
              •      the  replacement  string  in  double-quoted  pattern  substitution  does not
                     undergo quote removal, as it does in versions after bash-4.2
              •      in posix mode, single quotes are considered special when expanding the  word
                     portion  of  a  double-quoted parameter expansion and can be used to quote a
                     closing  brace  or  other  special  character  (this  is   part   of   POSIX
                     interpretation 221); in later versions, single quotes are not special within
                     double-quoted word expansions

       compat43
              •      the shell does not print a warning message if an attempt is made  to  use  a
                     quoted  compound  assignment  as  an  argument  to declare (e.g., declare -a
                     foo='(1 2)'). Later versions warn that this usage is deprecated
              •      word expansion errors are considered non-fatal errors that cause the current
                     command  to  fail,  even in posix mode (the default behavior is to make them
                     fatal errors that cause the shell to exit)
              •      when executing a shell function, the loop state (while/until/etc.)   is  not
                     reset, so break or continue in that function will break or continue loops in
                     the calling context. Bash-4.4 and later reset the loop state to prevent this

       compat44
              •      the shell sets up the values used by BASH_ARGV and  BASH_ARGC  so  they  can
                     expand  to the shell's positional parameters even if extended debugging mode
                     is not enabled
              •      a subshell inherits loops from its parent context, so break or continue will
                     cause  the  subshell  to  exit.   Bash-5.0 and later reset the loop state to
                     prevent the exit
              •      variable assignments preceding builtins like export and  readonly  that  set
                     attributes  continue  to  affect variables with the same name in the calling
                     environment even if the shell is not in posix mode

       compat50
              •      Bash-5.1 changed the way $RANDOM is generated  to  introduce  slightly  more
                     randomness.  If  the  shell  compatibility  level  is set to 50 or lower, it
                     reverts to the method from bash-5.0 and previous versions,  so  seeding  the
                     random number generator by assigning a value to RANDOM will produce the same
                     sequence as in bash-5.0
              •      If the command hash table is empty, bash versions prior to bash-5.1  printed
                     an informational message to that effect, even when producing output that can
                     be reused as input. Bash-5.1 suppresses that message when the -l  option  is
                     supplied.

       compat51
              •      The  unset  builtin  treats  attempts  to  unset  array  subscripts  @ and *
                     differently depending on whether the array is indexed  or  associative,  and
                     differently than in previous versions.

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, HISTFILE, ENV o BASH_ENV

       •      specificare nomi di comando contenenti una /

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

       •      specificare  un  nome-file  contenente  una barra obliqua come argomento al comando
              incorporato history

       •      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

       •      turning off restricted mode with set +r or shopt -u restricted_shell.

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

       When  a  command  that  is  found  to be a shell script is executed (see COMMAND EXECUTION
       above), rbash rimuove ogni restrizione  nella  shell  creata  dalla  shell  genitrice  per
       eseguire lo script.

VEDERE ANCHE

       Bash Reference Manual, Brian Fox e Chet Ramey
       The Gnu Readline Library, Brian Fox e Chet Ramey
       The Gnu History Library, Brian Fox e Chet Ramey
       Portable Operating System Interface (POSIX) Part 2: Shell and Utilities, IEEE --
              http://pubs.opengroup.org/onlinepubs/9699919799/
       http://tiswww.case.edu/~chet/bash/POSIX -- una descrizione della modalità posix
       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
       /etc/bash.bashrc
              Il file di inizializzazione generale di sistema per ogni shell interattiva
       /etc/bash.bash.logout
              Il  file  di  pulizia della shell di login generale di sistema, eseguito quando una
              shell di login termina
       ~/.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
       ~/.bash_history
              The default value of HISTFILE, the file in which bash saves the command history
       ~/.inputrc
              Il file di inizializzazione individuale per readline

AUTORI

       Brian Fox, Free Software Foundation
       bfox@gnu.org

       Chet Ramey, Case Western Reserve University
       chet.ramey@case.edu

NOTIFICA DEI "BUG"

       If  you find a bug in bash, you should report it.  But first, you should make sure that it
       really is a bug, and that it appears in the latest version of bash.  The latest version is
       always          available         from         ftp://ftp.gnu.org/pub/gnu/bash/         and
       http://git.savannah.gnu.org/cgit/bash.git/snapshot/bash-master.tar.gz.

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

       TUTTI i rapporti sui "bug" dovranno includere:

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

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

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

BUG

       È troppo grande e troppo lenta.

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

       In alcuni casi gli alias possono essere causa di confusione.

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

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

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

       Ci può essere solo un coprocesso attivo alla volta.

TRADUZIONE

       La traduzione italiana di questa pagina di manuale  è  stata  creata  da  Augusto  Lenardi
       <augusto@comune.modena.it>,  Antonio  Giovanni Colombo <azc100@gmail.com>, Silvano Sallese
       <silvano@pluto.it> e Marco Curreli <marcocurreli@tiscali.it>

       Questa traduzione è documentazione libera; leggere la GNU General Public License  Versione
       3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ o successiva per le condizioni di copyright.
       Non ci assumiamo alcuna responsabilità.

       Per segnalare errori nella traduzione di questa pagina di manuale inviare un  messaggio  a
       ⟨pluto-ildp@lists.pluto.it⟩.