% Linux Guida dell'Utente                   -*- TeX -*-
  % shell.tex
  % Copyright (c) 1993, 1994 by Larry Greenfield
  %
  % Traduzione di Eugenia Franzoni, 1997
  %
  % Questo file e' liberamente distribuibile, ma si deve preservare questo
  % avviso di copyright su tutte le copie, e deve essere distribuito solo come
  % parte di "Linux Guida dell'Utente". L'uso di questo file e'
  % protetto dal copyright dell'intero documento, nel file "copyright.tex".
  
  % Titolo del capitolo
  \chapter{La shell di \unix}\label{shell-chapter}
  
  % Frasetta estratta dal programma fortune e non tradotta...
  % \begin{verse}
  % A UNIX saleslady, Lenore,\\
  % Enjoys work, but she likes the beach more.\\
  % \hspace{0.5in}She found a good way\\
  % \hspace{0.5in}To combine work and play:\\
  % She sells C shells by the seashore.
  % \end{verse}
  \glossary{C shell}\glossary{Bourne shell}
  \glossary{file}\glossary{input}\glossary{output}
  
  \section{Comandi di \unix}
  
  Quando vi loggate la prima volta in un sistema \unix, vi si presenta
  qualcosa del genere:
  
  \begin{screen}\begin{verbatim}
  /home/larry$
  \end{verbatim}\end{screen}
  
  Si chiama {\bf prompt}.\index{shell!prompt} Come pu\`o 
  suggerire il
  nome, vi chiede di inserire un comando. Ogni comando UNIX \`e una
  sequenza di lettere, numeri e caratteri, senza spazi. Alcuni comandi
  validi sono {\tt mail}, {\tt cat} e {\tt CMU\_is\_Number-5}.
  Alcuni caratteri non sono permessi---verranno elencati pi\`u avanti. UNIX
  \`e anche {\bf case-sensitive} (sensibile al maiuscolo/minuscolo);
  cio\`e {\tt
  cat} e {\tt Cat} sono comandi
  diversi\footnote{La sensibilit\`a al maiuscolo/minuscolo \`e una cosa
  particolare. Alcuni sistemi operativi, come OS/2\index{OS/2} o Windows
  NT\index{Windows NT} mantengono i nomi in maiuscolo o minuscolo, ma
  non fanno distinzioni. In pratica \`e difficile che due comandi UNIX
  differiscano solo per una lettera maiuscola invece che minuscola. Non
  \`e normale avere due comandi diversi come {\tt cat} e {\tt Cat}.}.
  
  Il prompt viene visualizzato da un programma speciale, la {\bf
  shell}\index{shell}. La shell accetta comandi e li esegue;
  esistono
  anche programmi scritti in un linguaggio proprio della shell, e si
  chiamano ``shell script''\index{shell!programmi}\index{shell!script}.
  
  In UNIX ci sono due tipi principali di shell, le Bourne shell e le C
  shell.
  Le Bourne shell prendono il nome dal loro inventore, Steven
  Bourne.\index{Bourne, Steve R.} Steven Bourne ha scritto la shell
  UNIX originale, {\tt sh}\ttindex{sh}, e da allora la maggior parte
  delle shell hanno nomi che finiscono in {\tt sh} per indicare che
  sono estensioni dell'idea originale.
  Ci
  sono molte
  implementazioni della sua shell, e si chiamano tutte Bourne shell.
  \`E comune anche un'altra classe di shell, la C shell (originariamente
  implementata da
  Bill Joy\index{Joy,            
    Bill}). Tradizionalmente, le 
  Bourne shell vengono usate per gli script di shell e per
  compatibilit\`a con l'originale, e le C shell sono usate
  per l'uso
  interattivo (le C shell hanno il vantaggio di avere caratteristiche
  di interattivit\`a migliori, ma sono pi\`u difficili da programmare).
  
  Linux viene fornito con una Bourne shell chiamata {\tt
  bash}\ttindex{bash},
  scritta dalla Free Software Foundation\index{Free Software
  Foundation}. {\tt bash} sta per {\bf B}ourne {\bf
  A}gain {\bf Sh}ell, uno dei tanti brutti giochi di parole in \unix.
  \`E una
  Bourne shell ``avanzata'': contiene le caratteristiche standard di
  programmazione normalmente presenti nelle Bourne shell, insieme con
  molte caratteristiche di interattivit\`a normalmente presenti nelle C
  shell. {\tt bash} \`e la shell di default che viene usata con \linux.
  
  Quando vi loggate, il prompt viene mostrato da {\tt bash}, e state
  eseguendo
  il vostro primo programma \unix, la {\tt bash} shell. Finch\'e sarete
  loggati, la bash shell continuer\`a a girare.
  
  
  \subsection{Un tipico comando \unix}
  
  Il primo comando da conoscere \`e {\tt cat}\ttindex{cat}. Per usarlo,
  digitate {\tt cat} e premete \ret:
  
  \begin{screen}\begin{verbatim}
  /home/larry$ cat
  \end{verbatim}\end{screen}
  
  Se il cursore si trova da solo in una nuova linea, avete fatto tutto giusto.
  Ci sono diverse varianti che avreste potuto scrivere---alcune
  funzionano,
  altre no.
  
  \begin{itemize}
  \item Se aveste sbagliato a scrivere {\tt cat}, avreste visto:
  \begin{screen}\begin{verbatim}
  /home/larry$ ct
  ct: command not found
  /home/larry$
  \end{verbatim}\end{screen}
  In questo modo la shell vi informa che non ha trovato un programma chiamato
  ``{\tt ct}'' e propone un altro prompt per lavorare. Ricordatevi, UNIX fa
  differenze tra maiuscolo e minuscolo: {\tt CAT} \`e errato.
  
  \item Potreste aver anteposto alcuni spazi bianchi prima del comando, come
  qui\footnote{Il carattere `{\tt \char `\ }' indica che l'utente ha inserito
  uno spazio.}:
  \begin{screen}\begin{verbatim*}
  /home/larry#     cat     
  \end{verbatim*}\end{screen}
  Questo produce il risultato corretto ed esegue il programma {\tt cat}.
  
  % altre idee di errori comuni?
  
  \item Potreste anche aver premuto \ret\ in una riga da solo. Andate
  avanti---non \`e successo assolutamente niente.
  \end{itemize}
  
  Presumo che adesso siate in {\tt cat}. Probabilmente vi state
  chiedendo
  che cosa fa. No, non \`e un
  gioco.
  {\tt cat} \`e un potente strumento anche se per il momento non sembra.
  Scrivete qualcosa e premete \ret. Quello che dovreste vedere \`e:
  
  \begin{tscreen}
  /home/larry\$ cat\\
  {\sl Aiuto! Sono incastrato in un programma Linux!}\\
  Aiuto! Sono incastrato in un programma Linux!
  \end{tscreen}
  
  (Il testo {\sl obliquo\/} indica quello che ha scritto l'utente.) Quello che
  sembra fare {\tt cat} \`e copiare sullo schermo quello che l'utente
  scrive. A volte \`e utile, ma non ora. Usciamo da questo programma e
  passiamo ad altri comandi che abbiano un'utilit\`a pi\`u evidente.
   
  Per chiudere molti comandi \unix, digitate \eof\footnote{Tenete
  premuto il
  tasto ``Ctrl'' e premete ``d'', poi lasciateli entrambi.}. \eof\ \`e il
  carattere di
  fine-file (End-Of-File), o EOF per
  abbreviare\index{end-of-text}\index{end-of-file}. In
  alternativa, sta per fine-del-testo, a seconda di quale libro avete letto.
  Mi riferir\`o ad esso come fine-file. \`E un carattere di controllo che
  comunica ai programmi UNIX che voi (o un altro programma) avete finito di
  inserire dati. Quando {\tt cat} vede che non state scrivendo niente 
  altro, termina.
  
  Per avere un'idea, provate il programma {\tt sort}\ttindex{sort}. Come
  indica il nome, \`e un programma di ordinamento: se inserite un
  paio
  di linee e poi premete \eof, le visualizzer\`a in ordine
  alfabetico. Questo tipo di programmi sono chiamati {\bf
  filtri}\glossary{filter}, perch\'e prendono un testo, lo filtrano e lo
  mandano fuori in modo diverso. Sia {\tt cat} che {\tt sort} sono
  filtri particolari: {\tt cat} \`e particolare perch\'e legge il testo per
  linee e non fa \emph{nessuna} azione su di esso, {\tt sort}
  perch\'e legge per linee e non rende nessun output finch\'e
  non ha visto il carattere EOF\@. Molti filtri agiscono linea per linea:
  leggono una linea, fanno dei calcoli, e rendono come output una linea
  diversa.
  
  \section{Come cavarsela da soli}
  \label{man-section}\bindex{guida in linea}
  
  Il comando {\tt man}\impttindex{man} mostra delle pagine di riferimento per
  il comando\footnote{man d\`a informazioni anche su chiamate di sistema,
  subroutine, formati di file ed altro. Nella versione originale di
  UNIX dava esattamente le stesse informazioni della versione
  stampata. Per ora, probabilmente, sarete interessati soltanto alla
  documentazione sui comandi.} che specificate. Per esempio:
  
  \begin{screen}\begin{verbatim}
  /home/larry$ man cat
  
  cat(1)                                                     cat(1)
  
  NOME
    cat - Concatena o visualizza file
  
  SINTASSI
    cat [-benstuvAET] [--number] [--number-nonblank] [--squeeze-blank]
    [--show-nonprinting] [--show-ends] [--show-tabs] [--show-all]
    [--help] [--version] [file...]
  
  DESCRIZIONE
    Questa pagina documenta la versione GNU del comando cat ...
  \end{verbatim}\end{screen}
  
  C'\`e una pagina intera di informazioni su {\tt cat}. Provate, ma
  non
  aspettatevi di capire tutto. Le pagine man assumono che voi
  conosciate diverse cose che ancora non sapete.
  Quando avrete letto la pagina, c'\`e probabilmente un 
  rettangolino in basso sullo schermo, con la scritta {\tt --more--},
  {\tt Line
  1} o qualcosa di simile. \`E il prompt di {\tt more}, ed
  imparerete ad amarlo.
  
  Invece di lasciar scorrere il testo, {\tt man} lo ferma alla fine di
  ogni
  videata, e aspetta.
  Se volete
  proseguire, premete \key{Spazio} e avanzerete di una videata. Se volete
  uscire (quit) dalla pagina che state leggendo, premete \key{q}: ritornerete
  al prompt della shell, pronta a ricevere un nuovo comando.
  
  Si possono anche dare delle opzioni a {\tt man}. Per
  esempio, poniamo che siate
  interessati ad un comando per interagire con il Postscript, il linguaggio di
  controllo delle stampanti di Adobe. Digitate {\tt man -k ps} o {\tt man -k
  Postscript}, otterrete una lista di comandi, chiamate di sistema e
  altre parti
  documentate di UNIX che hanno la parola ``ps'' (o ``Postscript'')
  nel nome
  o nella descrizione breve; pu\`o essere molto utile quando state
  cercando
  un programma che faccia qualcosa, ma non sapete il suo nome---o neanche se
  esiste!
  
  \eindex{guida in linea}
  
  \section{Memorizzare le informazioni}
  
  I filtri sono molto utili quando si \`e utenti esperti, ma
  hanno un piccolo problema: come si memorizzano le informazioni?
  Sicuramente non
  vorrete scrivere tutto ogni volta che utilizzate un programma! Certo che no:
  UNIX fornisce {\bf file} e {\bf directory}\glossary{directory}.
  
  Una directory \`e simile ad una cartella: contiene pezzi di carta, o
  file (archivi). Una grossa cartella pu\`o anche contenere altre
  cartelle---le
  directory possono essere contenute in altre directory.
  In \unix, la struttura delle directory e dei file \`e chiamata
  filesystem\index{file system}. Inizialmente, il filesystem consiste
  in una sola
  directory, chiamata directory di ``root''\index{directory!di root}. Dentro
  questa directory ci sono altre directory, e dentro queste directory ci sono
  file e ancora altre directory.\footnote{Pu\`o esserci o non esserci un
  limite di ``profondit\`a'' in un filesystem (io non l'ho mai
  raggiunto---si possono facilmente avere
  directory nidificate 10 volte.}
  
  Ogni file e ogni directory ha un nome. Ha sia un nome breve, che pu\`o
  essere lo stesso di un altro file o directory in un altro punto del sistema,
  e un nome esteso, che \`e univoco. Un nome breve per un file potrebbe
  essere {\tt
  joe}, mentre il suo ``nome esteso'' potrebbe essere {\tt /home/larry/joe}.
  Il nome esteso \`e chiamato comunemente {\bf
  path}\glossary{path}
  (percorso). Il path pu\`o essere decodificato in una sequenza di directory.
  Per esempio, vediamo come viene letto {\tt /home/larry/joe}:
  \begin{tabbing}
  \tt /\=\tt home/\=\tt larry/\=\tt joe\\
  Per prima cosa, siamo nella directory root.\+\\
  Questo sta per la directory chiamata {\tt home}. Si trova dentro la directory root.\+\\
  Questa \`e la directory {\tt larry}, che sta dentro {\tt home}.\+\\
  {\tt joe} \`e dentro {\tt larry}. Un percorso si pu\`o riferire sia ad una directory che ad un file,\\ quindi {\tt joe} pu\`o essere sia l'uno che l'altro. Tutto quello che precede l'ultimo\\ elemento sono directory.
  \end{tabbing}
  
  Un modo semplice per visualizzare questa struttura \`e usare un
  diagramma ad
  albero. Per vedere un diagramma di un tipico sistema \linux, guardate
  la
  figura~\ref{standard-dirtree}. Notate che questo diagramma non \`e
  completo---un sistema Linux reale ha pi\`u di 8000 file!---e mostra solo
  alcune delle directory pi\`u comuni. Cos\`{\i} ci possono essere alcune
  directory nel diagramma che non esistono nel vostro sistema, e
  certamente il vostro
  sistema ha directory non elencate qui.
  
  \unitlength=1.0pt
  \begin{figure}[bt]
  \caption{Un tipico albero di directory Unix.}
  \label{standard-dirtree}
  \begin{picture}(148.00,365.00)(0.00,450.00)
  \put(9.00,805.00){\line(1,0){29.00}} % / -> bin
  \put(26.00,805.00){\line(0,-1){112.00}} % /'s children
  \put(26.00,791.00){\line(1,0){12.00}} % dev
  \put(26.00,777.00){\line(1,0){12.00}} % etc
  \put(26.00,763.00){\line(1,0){12.00}} % home
  \put(64.50,763.00){\line(1,0){29.00}} % home -> larry
  \put(81.50,763.00){\line(0,-1){14.00}} % home's children
  \put(81.50,749.00){\line(1,0){12.00}} % sam
  \put(26.00,735.00){\line(1,0){12.00}} % lib
  \put(26.00,721.00){\line(1,0){12.00}} % proc
  \put(26.00,707.00){\line(1,0){12.00}} % tmp
  \put(26.00,693.00){\line(1,0){12.00}} % usr
  \put(55.50,693.00){\line(1,0){29.00}} % usr -> X386
  \put(72.50,693.00){\line(0,-1){238.00}} % usr's children
  \put(72.50,676.00){\line(1,0){12.00}} % bin
  \put(72.50,659.00){\line(1,0){12.00}} % emacs
  \put(72.50,642.00){\line(1,0){12.00}} % etc
  \put(72.50,625.00){\line(1,0){12.00}} % g++-include
  \put(72.50,608.00){\line(1,0){12.00}} % include
  \put(72.50,591.00){\line(1,0){12.00}} % lib
  \put(72.50,574.00){\line(1,0){12.00}} % local
  \put(107.00,574.00){\line(1,0){29.00}} % local -> bin
  \put(124.00,574.00){\line(0,-1){51.00}} % local's children
  \put(124.00,557.00){\line(1,0){12.00}} % emacs
  \put(124.00,540.00){\line(1,0){12.00}} % etc
  \put(124.00,523.00){\line(1,0){12.00}} % lib
  \put(72.50,506.00){\line(1,0){12.00}} % man
  \put(72.50,489.00){\line(1,0){12.00}} % spool
  \put(72.50,472.00){\line(1,0){12.00}} % src
  \put(100.50,472.00){\line(1,0){29.00}} % src -> linux
  \put(72.50,455.00){\line(1,0){12.00}} % tmp
  \put(8.50,805.00){\makebox(0,0)[rc]{/}}
  \put(39.50,805.00){\makebox(0,0)[lc]{bin}}
  \put(39.50,791.00){\makebox(0,0)[lc]{dev}}
  \put(39.50,777.00){\makebox(0,0)[lc]{etc}}
  \put(39.50,763.00){\makebox(0,0)[lc]{home}}
  \put(95.00,763.00){\makebox(0,0)[lc]{larry}}
  \put(95.00,749.00){\makebox(0,0)[lc]{sam}}
  \put(39.50,735.00){\makebox(0,0)[lc]{lib}}
  \put(39.50,721.00){\makebox(0,0)[lc]{proc}}
  \put(39.50,707.00){\makebox(0,0)[lc]{tmp}}
  \put(39.50,693.00){\makebox(0,0)[lc]{usr}}      % I'm expecting you to
  \put(86.00,693.00){\makebox(0,0)[lc]{X386}}     % proof-read this!
  \put(86.00,676.00){\makebox(0,0)[lc]{bin}}      
  \put(86.00,659.00){\makebox(0,0)[lc]{emacs}}    % I am, I am, don't worry! :-)
  \put(86.00,642.00){\makebox(0,0)[lc]{etc}}	% Translating is  easier! :)
  \put(86.00,625.00){\makebox(0,0)[lc]{g++-include}}
  \put(86.00,608.00){\makebox(0,0)[lc]{include}}
  \put(86.00,591.00){\makebox(0,0)[lc]{lib}}
  \put(86.00,574.00){\makebox(0,0)[lc]{local}}
  \put(137.50,574.00){\makebox(0,0)[lc]{bin}}      % Come on, all of it!
  \put(137.50,557.00){\makebox(0,0)[lc]{emacs}}
  \put(137.50,540.00){\makebox(0,0)[lc]{etc}}
  \put(137.50,523.00){\makebox(0,0)[lc]{lib}}
  \put(86.00,506.00){\makebox(0,0)[lc]{man}}
  \put(86.00,489.00){\makebox(0,0)[lc]{spool}}
  \put(86.00,472.00){\makebox(0,0)[lc]{src}}
  \put(130.50,472.00){\makebox(0,0)[lc]{linux}}
  \put(86.00,455.00){\makebox(0,0)[lc]{tmp}}
  \end{picture}
  \end{figure}
  
  
  \subsection{Vedere le directory con {\tt ls}}
  
  Adesso che sapete che esistono i file e le directory, ci sono vari
  modi per
  manipolarli: vediamo quali sono. Il comando {\tt ls}\ttindex{ls} \`e uno dei
  pi\`u importanti: fa una {\bf l}i{\bf s}ta di file. Se provate {\tt ls} come
  comando, vedrete:
  
  \begin{screen}\begin{verbatim}
  /home/larry$ ls
  /home/larry$
  \end{verbatim}\end{screen}
  
  \`E giusto, non vedete niente. UNIX \`e intenzionalmente conciso: se
  non esistono file non d\`a niente, invece di dire ``nessun file''.
  Cos\`{\i}
  l'assenza di dati \`e il modo in cui {\tt ls} dice che non ha trovato
  nessun file.
  
  Ma allora, se ho detto che possono esserci 8000 o pi\`u file in giro, dove
  sono? Arriviamo quindi al concetto di directory ``corrente''. Potreste
  vedere nel prompt che la vostra directory corrente \`e {\tt /home/larry}, dove
  non avete ancora nessun file. Se volete la lista dei file di una directory
  pi\`u importante, provate con la directory di root:
  
  \begin{screen}\begin{verbatim}
  /home/larry$ ls /
  bin      etc      install  mnt      root     user     var
  dev      home     lib      proc     tmp      usr      vmlinux
  /home/larry$ 
  \end{verbatim}\end{screen}
  
  Nel precedente comando, ``{\tt ls /}'', la directory (``{\tt /}'') \`e
  un {\bf parametro}.
  La prima parola del comando \`e il nome del comando, e tutto il resto sono
  parametri. I parametri generalmente modificano l'oggetto del
  comando---per {\tt ls}, i parametri indicano di quale directory si
  vuole l'elenco.
  Alcuni comandi hanno speciali parametri chiamati {\bf opzioni} o
  {\bf switch}. Per vederlo, provate:
  
  \begin{screen}\begin{verbatim}
  /home/larry$ ls -F /
  bin/      etc/      install/  mnt/      root/     user/     var@
  dev/      home/     lib/      proc/     tmp/      usr/      vmlinux
  /home/larry$ 
  \end{verbatim}\end{screen}
  
  {\tt -F} \`e un'opzione, cio\`e un tipo speciale di parametro che
  comincia con un trattino e modifica il modo di agire del programma,
  ma non il suo oggetto. Per {\tt ls}, {\tt -F} \`e un'opzione
   che permette di vedere quali sono le directory,
  quali i file speciali e quali i file normali. Tutti quelli che
  terminano con una
  barra sono directory. Parleremo ancora delle caratteristiche di {\tt ls}
  pi\`u avanti: \`e un programma sorprendentemente complesso!
  
  Ora, ci sono due lezioni da imparare qui. Per prima cosa dovete
  imparare
  quello che
  fa {\tt ls}. Provate un po' di directory mostrate nella
  figura~\ref{standard-dirtree}, e guardate cosa contengono. Naturalmente
  alcune saranno vuote, e alcune avranno molti, molti file. Suggerisco di
  provare {\tt ls} sia con sia senza l'opzione {\tt -F}. Per esempio, {\tt ls
  /usr/local} sar\`a pi\`u o meno:
  
  \begin{screen}\begin{verbatim}
  /home/larry$ ls /usr/local
  archives  bin       emacs     etc       ka9q      lib       tcl
  /home/larry$ 
  \end{verbatim}\end{screen}
  
  La seconda lezione \`e pi\`u generale: molti comandi UNIX sono simili a
  {\tt ls}, cio\`e hanno opzioni, che generalmente consistono di un trattino
  seguito da un carattere, e parametri. 
  Diversamente da {\tt ls}, alcuni comandi 
  {\em richiedono\/} determinati parametri e/o opzioni.
  Per mostrare come un comando usa opzioni e parametri, useremo la seguente
  forma:
  
  \begin{quote}
  {\tt ls} [-arF] [{\sl directory}]
  \end{quote}
  
  Questo \`e un modello di comando e lo vedrete ogni volta che viene
  introdotto un nuovo comando. 
  La prima parola \`e il comando stesso (in questo caso {\tt ls}). Dopo
  il comando ci sono i parametri; quelli opzionali vengono
  racchiusi tra parentesi quadre  (``['' e ``]''). 
  Le meta-variabili sono {\sl inclinate\/}---sono parole che vanno
  sostituite con i parametri reali (ad esempio, qui sopra vedete {\sl
  directory}, che va sostituito con il nome di una directory reale). 
  
  Le opzioni sono un caso speciale. Vengono racchiuse tra parentesi, ma 
  se ne pu\`o usare una sola senza usarle tutte. Ad esempio, con le tre
  sole opzioni date qui sopra per {\tt ls}, si hanno otto diversi modi
  per dare il comando: con o senza ciascuna delle opzioni.
  (Paragonate {\tt ls -R} con {\tt ls -F}.)
  
  \subsection{La directory corrente e {\tt cd}}
  
  \begin{command}
  {\tt pwd}
  \end{command}
  
  Usare le directory sarebbe  scomodo se doveste scrivere il percorso
  completo ogni volta che voleste accedere ad una directory. Invece, le
  shell
  UNIX hanno una caratteristica chiamata directory ``corrente'' o
  ``di lavoro''. Il vostro setup probabilmente vi mostra la
  directory corrente nel prompt:
  {\tt /home/larry}; se non lo fa, provate il comando {\tt pwd}, per {\bf
  p}resent {\bf w}orking {\bf d}irectory (visualizza la directory di lavoro).
  Talvolta il prompt vi mostrer\`a il nome della macchina: una cosa del
  genere \`e utile solo in un ambiente di rete con molte macchine
  diverse. 
  \ttindex{pwd}
  \index{directory!corrente}
  \index{directory!di lavoro}
  
  \begin{screen}
  \begin{verbatim}
  mousehouse>pwd
  /home/larry
  mousehouse>  
  \end{verbatim}
  \end{screen}
  
  \begin{command}
  {\tt cd} [{\sl directory}]
  \end{command}
  
  Come potete vedere, {\tt pwd} mostra la vostra directory
  corrente\footnote{Troverete tutti i termini in questo libro:
  directory corrente,
  directory di lavoro. Preferisco ``directory corrente'', sebbene a
  volte verranno usate le
  altre forme per motivi stilistici.}---un comando molto semplice.
  Molti comandi agiscono, per default, nella directory corrente.
  Per esempio, {\tt ls} senza nessun parametro ne mostra il contenuto.
   Possiamo cambiare la directory corrente usando il comando {\tt
  cd}\ttindex{cd}: per esempio, provate:
  
  \begin{screen}\begin{verbatim}
  /home/larry$ cd /home
  /home$ ls -F
  larry/     sam/       shutdown/  steve/     user1/
  /home$ 
  \end{verbatim}\end{screen}
  
  Se omettete il parametro opzionale {\sl directory}, ritornerete alla
  vostra home directory, o
  directory di origine, altrimenti {\tt cd} vi porter\`a nella directory
  specificata. Per esempio:
  
  \begin{screen}\begin{verbatim}
  /home$ cd
  /home/larry$ cd /
  /$ cd home
  /home$ cd /usr
  /usr$ cd local/bin
  /usr/local/bin$
  \end{verbatim}\end{screen}
  
  Come potete vedere, {\tt cd} vi permette di usare percorsi sia
  assoluti sia
  relativi: un percorso ``assoluto'' inizia con {\tt /} e specifica tutte le
  directory prima della directory cercata, un percorso relativo \`e preso in
  relazione alla directory corrente. Nell'esempio precedente, quando ero in
  {\tt /usr}, ho fatto uno spostamento relativo a {\tt local/bin}---{\tt
  local} \`e una directory dentro {\tt usr}, e {\tt bin} \`e una directory
  dentro {\tt local}.
  
  Ci sono due directory usate {\em solamente\/} nei percorsi
  relativi: ``{\tt.}''
  e ``{\tt ..}''\index{directory!corrente}\index{directory!madre}. La
  directory ``{\tt .}'' si riferisce alla directory corrente e ``{\tt ..}''
  \`e la directory madre, cio\`e quella che contiene la directory corrente.
  Sono directory ``scorciatoia'': esistono in {\em ogni\/} directory,
  ma non seguono il concetto di ``cartella in cartella''. Anche la
  directory di root ha una directory madre---\`e la directory di root stessa!
  
  Il file {\tt./chapter-1} \`e il file chiamato {\tt chapter-1} nella
  directory corrente. Occasionalmente \`e necessario inserire il ``{\tt ./}''
  per far funzionare alcuni comandi, sebbene questo sia raro. In molti casi,
  {\tt ./chapter-1} e {\tt chapter-1} sono la stessa cosa.
  
  La directory ``{\tt ..}'' \`e molto utile per tornare indietro 
  nell'albero:
  
  \begin{screen}\begin{verbatim}
  /usr/local/bin$ cd ..
  /usr/local$ ls -F
  archives/  bin/       emacs@     etc/       ka9q/      lib/       tcl@
  /usr/local$ ls -F ../src
  cweb/      linux/     xmris/
  /usr/local$
  \end{verbatim}\end{screen}
  
  In questo esempio, sono passato nella directory madre usando {\tt cd ..} e
  ho fatto l'elenco della directory {\tt /usr/src} da {\tt /usr/local}
  usando {\tt ../src}.
  Notate che se fossi stato in {\tt /home/larry}, inserire {\tt ls
  -F ../src} non sarebbe andato bene!
  
  La directory {\tt \verb+~+/} \`e equivalente alla
  vostra home directory\index{directory!home}:
  
  \begin{screen}\begin{verbatim}
  /usr/local$ ls -F ~/
  /usr/local$ 
  \end{verbatim}\end{screen}
  
  Potete vedere che non c'\`e niente nella vostra home directory. {\tt
  \verb+~+/} diverr\`a pi\`u utile quando impareremo come manipolare i
  file.
  
  \subsection{Creare e distruggere le directory}
  \index{mkdir@{\tt mkdir}|(}\bindex{directory!creazione} 
  
  \begin{command}
  {\tt mkdir} {\sl directory1} [{\sl directory2 \ldots directoryN}]
  \end{command}
  
  Creare directory \`e estremamente semplice sotto \unix, e pu\`o essere un
  ottimo strumento di organizzazione. Per creare una nuova directory, usate il
  comando {\tt mkdir}. {\tt mkdir} sta per {\bf m}a{\bf k}e {\bf dir}ectory
  (crea directory).
  
  Vediamo un piccolo esempio per vedere come lavora questo comando:
  \begin{screen}\begin{verbatim}
  /home/larry$ ls -F
  /home/larry$ mkdir report-1993
  /home/larry$ ls -F
  report-1993/
  /home/larry$ cd report-1993
  /home/larry/report-1993#
  \end{verbatim}\end{screen}
  
  {\tt mkdir} pu\`o gestire pi\`u di un parametro, e ne interpreta ognuno
  come una directory da creare. Si possono specificare sia
  percorsi assoluti sia relativi; nell'esempio precedente, {\tt report-1993}
  \`e un percorso relativo.
  
  \begin{screen}\begin{verbatim}
  /home/larry/report-1993$ mkdir /home/larry/report-1993/chap1 ~/report-1993/chap2
  /home/larry/report-1993$ ls -F
  chap1/  chap2/
  /home/larry/report-1993$
  \end{verbatim}\end{screen}
  
  L'opposto di {\tt mkdir} \`e {\tt rmdir} per {\bf r}e{\bf m}ove
  {\bf dir}ectory (rimuovi directory). {\tt rmdir} funziona esattamente
  come {\tt mkdir}.
  \ttindex{rmdir}
  
  
  Un esempio di {\tt rmdir} \`e:
  
  \begin{screen}\begin{verbatim}
  /home/larry/report-1993$ rmdir chap1 chap3
  rmdir: chap3: No such file or directory
  /home/larry/report-1993$ ls -F
  chap2/
  /home/larry/report-1993$ cd ..
  /home/larry# rmdir report-1993
  rmdir: report-1993: Directory not empty
  /home/larry$
  \end{verbatim}\end{screen}
  
  Come potete vedere, {\tt rmdir} si rifiuta di rimuovere directory
  che non esistono, come anche directory che contengono qualcosa
  (ricordatevi che
  {\tt report-1993} ha una subdirectory all'interno, {\tt chap2}!). C'\`e
  un'altra cosa interessante su {\tt rmdir}: cosa succede se tentate di
  rimuovere la vostra directory corrente? Proviamo:
  
  \begin{screen}\begin{verbatim}
  /home/larry$ cd report-1993
  /home/larry/report-1993$ ls -F
  chap2/
  /home/larry/report-1993$ rmdir chap2
  /home/larry/report-1993$ rmdir .
  rmdir: .: Operation not permitted
  /home/larry/report-1993$
  \end{verbatim}\end{screen}
  
  Un'altra situazione che potreste considerare \`e cosa succede se
  provate a
  rimuovere la madre della directory corrente. In effetti questo non \`e un
  problema: la madre della directory corrente non \`e vuota, e quindi non
  pu\`o essere rimossa!
  \index{mkdir@{\tt mkdir}|)}\eindex{directory!creazione}
  
  \section{Spostare Informazioni}
  
  Tutte queste directory sono bellissime, ma non ci servono a niente, se non
  come posto dove immagazzinare i dati. Gli
  Dei dello UNIX \index{Dei!\unix} hanno visto questo
  problema, e l'hanno risolto dando agli utenti i file.
  
  Impareremo a
  creare e modificare i file nei prossimi capitoli.
  
  I principali comandi per manipolare i file in UNIX sono {\tt
  cp}\ttindex{cp}, {\tt mv}\ttindex{mv} e {\tt rm}\ttindex{rm}.
  Rispettivamente questi stanno per {\bf c}o{\bf p}y (copia),
  {\bf m}o{\bf v}e
  (sposta) e {\bf r}e{\bf m}ove
  (rimuovi).
  
  
  \subsection{{\tt cp} come un amanuense}
  \bttindex{cp}
  
  \begin{command}
  {\tt cp} [-i] {\sl origine} {\sl destinazione}\\
  {\tt cp} [-i] {\sl file1 file2 \ldots fileN} {\sl
    directory di destinazione}\footnote{{\tt cp} nel suo modello ha due
  linee perch\'e il significato del secondo parametro pu\`o essere diverso
  a seconda del numero di parametri.}
  \end{command}
  
  {\tt cp} \`e uno strumento molto utile sotto \unix, ed estremamente potente: 
  permette ad una persona di copiare pi\`u informazioni in un secondo
  di un monaco amanuense in un anno.
  
  \blackdiamond Fate attenzione con {\tt cp} se non avete molto spazio nel
  disco. Nessuno vuole vedere il messaggio {\tt Error saving--disk
  full} mentre sta copiando dei dati importanti. {\tt cp}
  pu\`o anche sovrascrivere i file esistenti senza avvisare---parler\`o di
  questi pericoli
  pi\`u avanti.
  
  Per prima cosa parleremo della prima linea del modello del comando: 
  il primo parametro di {\tt cp} \`e il file da copiare, il secondo \`e
  dove
  copiarlo. Si pu\`o copiare con un nuovo nome o su una diversa directory.
  Proviamo alcuni esempi:
  
  \begin{screen}\begin{verbatim}
  /home/larry# ls -F /etc/passwd
  /etc/passwd
  /home/larry# cp /etc/passwd .
  /home/larry# ls -F
  passwd
  /home/larry# cp passwd frog
  /home/larry# ls -F
  frog  passwd
  /home/larry#
  \end{verbatim}
  \end{screen}
  
  Con il primo {\tt cp} ho copiato il file 
   {\tt /etc/passwd}\ttindex{/etc/passwd}, che contiene i nomi di tutti
  gli utenti del sistema UNIX e le loro password (criptate),
  nella mia home directory. {\tt cp}
  non elimina il file sorgente; in questo modo non ho fatto niente che possa
  danneggiare il sistema. Cos\`{\i} adesso esistono due copie di {\tt
  /etc/passwd}
  nel mio sistema, entrambe chiamate {\tt passwd}, una nella
  directory
  {\tt /etc} e una in {\tt /home/larry}.
  
  Poi ho creato una {\em terza\/} copia di 
  {\tt /etc/passwd}\ttindex{/etc/passwd} quando ho
  scritto 
  {\tt cp passwd frog}---le tre copie sono: 
  {\tt /etc/passwd}, {\tt                
    /home/larry/passwd} e {\tt /home/larry/frog}.
  Il contenuto di questi tre
  file \`e lo stesso, anche se hanno nomi diversi.
  
  {\tt cp} pu\`o copiare file tra directory se il primo parametro \`e un
  file e il secondo una directory; in questo caso, il nome breve del
  file resta lo stesso.
  
  Pu\`o copiare un file e cambiarne il nome se entrambi i parametri sono
  nomi di file. Questo \`e un pericolo di {\tt cp}: se io avessi scritto 
  {\tt cp
  /etc/passwd /etc/group}, {\tt cp} avrebbe creato un nuovo file con
  contenuto
  identico a {\tt passwd} e l'avrebbe chiamato {\tt group}, ma
  se {\tt /etc/group}
  esisteva gi\`a, {\tt cp} avrebbe distrutto il vecchio file senza darvi
  la possibilit\`a di
  salvarlo! (Non avrebbe nemmeno stampato un messaggio facendovi
  presente che stavate distruggendo un file copiandocene un altro
  sopra!)
  
  Vediamo un altro esempio di {\tt cp}:
  \begin{screen}\begin{verbatim}
  /home/larry# ls -F
  frog  passwd
  /home/larry# mkdir passwd_version
  /home/larry# cp frog passwd passwd_version
  /home/larry# ls -F
  frog         passwd        passwd_version/
  /home/larry# ls -F passwd_version
  frog  passwd
  /home/larry#
  \end{verbatim}
  \end{screen}
  
  Come ho usato {\tt cp}? Evidentemente {\tt cp} accetta {\em pi\`u\/} di
  due parametri (\`e la seconda linea nel modello del comando). Quello
  che ha fatto il comando precedente \`e stato copiare
  tutti i file elencati 
  ({\tt frog} e {\tt passwd}) e metterli nella
  directory {\tt passwd\_version}. In effetti {\tt cp} pu\`o prendere un
  numero
  qualsiasi di parametri, interpretando i primi $n-1$ parametri come file da
  copiare, e l'$n^{\rm mo}$ come directory in cui copiarli.
  
  \blackdiamond Non si possono rinominare i file quando se ne copiano
  pi\`u di uno alla volta---mantengono sempre il loro nome. Questo
  porta ad una domanda
  interessante: cosa succede se scrivo {\tt cp inittab pippo pluto}, dove
  {\tt inittab} e {\tt pippo} esistono e {\tt pluto} non \`e una directory?
  Provate e vedrete.
  
  \ettindex{cp}
  
  \subsection{Eliminare file con {\tt rm}}
  \bttindex{rm}
  
  \begin{command}
  {\tt rm} [-i] {\sl file1 file2 \ldots fileN}
  \end{command}
  
  Adesso che abbiamo imparato a creare milioni di file con {\tt
  cp}\ttindex{cp} (e credetemi, troverete presto nuovi modi per creare
  altri file),
  \`e utile imparare anche come eliminarli. \`E molto semplice, il comando che
  state cercando \`e {\tt rm}, e funziona proprio come state pensando:
  qualsiasi file che date come parametro a {\tt rm} viene cancellato.
  
  Per esempio:
  \begin{screen}\begin{verbatim}
  /home/larry$ ls -F
  inittab      pippo     rc_version/
  /home/larry$ rm inittab pippo pluto
  rm: pluto: No such file or directory
  /home/larry$ ls -F
  rc_version/
  /home/larry$
  \end{verbatim}\end{screen}
  
  Come potete vedere, {\tt rm} non \`e molto amichevole: non solo non chiede
  conferma, ma elimina file anche se l'intera riga non \`e corretta, che
  pu\`o essere pericoloso. Considerate la differenza tra questi due comandi:
  
  \begin{screen}\begin{verbatim}
  /home/larry$ ls -F
  pippo  pluto/
  /home/larry$ ls -F pluto
  pippo
  /home/larry$ rm pluto/pippo
  /home/larry$
  \end{verbatim}\end{screen}
  
  e questo
  
  \begin{screen}\begin{verbatim}
  /home/larry$ rm pluto pippo
  rm: pluto is a directory
  /home/larry$ ls -F
  pluto/
  /home/larry$
  \end{verbatim}\end{screen}
  
  \blackdiamond Come potete vedere, cambiare {\em un solo\/}
  carattere
  comporta un esito molto diverso del comando. \`E vitale controllare il
  comando inserito prima di battere \ret.
  
  \ettindex{rm}
  
  
  \subsection{Una scorciatoia molto utile}
  \bttindex{mv}
  
  \begin{command}
  {\tt mv} [-i] {\sl vecchio-nome} {\sl nuovo-nome}\\
  {\tt mv} [-i] {\sl file1 file2 \ldots fileN} {\sl nuova-directory}
  \end{command}
  
  Infine, l'altro comando che dovrete conoscere \`e {\tt mv}. {\tt
  mv}
  \`e simile a {\tt cp}, tranne che elimina il file originale dopo averlo
  copiato.
  \`E quindi molto simile all'uso di {\tt cp} e {\tt rm} insieme. Vediamo cosa
  possiamo fare:
  
  \begin{screen}\begin{verbatim}
  /home/larry$ cp /etc/inittab .
  /home/larry$ ls -F
  inittab
  /home/larry$ mv inittab pippo
  /home/larry$ ls -F
  pippo
  /home/larry$ mkdir report
  /home/larry$ mv pippo report
  /home/larry$ ls -F
  report/
  /home/larry$ ls -F report
  pippo
  /home/larry$
  \end{verbatim}\end{screen}
  
  Come potete vedere, {\tt mv} rinomina un file se il secondo parametro \`e un
  file. Se il secondo parametro \`e una directory, {\tt mv} sposta il file
  nella nuova directory mantenendo lo stesso nome breve.
  
  \blackdiamond Dovete fare molta attenzione con {\tt mv}---non controlla
  per vedere se il file di destinazione esiste gi\`a, e rimuover\`a tutti i  
  file che si trova tra i piedi. Per
  esempio, se ho gi\`a un file chiamato {\tt pippo} nella mia directory {\tt
  report}, il comando {\tt mv pippo report} eliminer\`a il file {\tt
  \verb+~+/report/pippo} e lo sostituir\`a con {\tt \verb+~+/pippo}.
  
  In effetti, c'\`e un modo per far s\`{\i} che {\tt rm}, {\tt cp} e {\tt mv}
  chiedano
  conferma prima di eliminare file. Tutti e tre i comandi accettano
  l'opzione {\tt -i}, con la quale chiedono conferma all'utente prima di
  cancellare qualsiasi file. Se usate un {\bf alias}, potete fare in
  modo che la shell faccia {\tt rm -i} automaticamente quando digitate
  {\tt rm}. Impareremo pi\`u su questo argomento nella
  Sezione~\ref{aliasing-section} a
  pagina~\pageref{aliasing-section}.
  
  \ettindex{mv}
  % Local Variables:
  % mode: latex
  % TeX-master: "guide"
  % End:
