%% LyX 1.1 created this file.  For more info, see http://www.lyx.org/.
%% Do not edit unless you really know what you are doing.
\documentclass[american,italian]{article}
\usepackage[T1]{fontenc}
\usepackage[latin1]{inputenc}
\usepackage{geometry}
\geometry{verbose,a4paper,tmargin=1cm,bmargin=1cm,lmargin=1cm,rmargin=1cm}
\usepackage{babel}
\usepackage{color}
\usepackage{graphics}
\usepackage{longtable}
\IfFileExists{url.sty}{\usepackage{url}}
                      {\newcommand{\url}{\texttt}}

\makeatletter


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% LyX specific LaTeX commands.
\providecommand{\LyX}{L\kern-.1667em\lower.25em\hbox{Y}\kern-.125emX\@}
\newenvironment{LyXParagraphIndent}[1]%
{
  \begin{list}{}{%
    \setlength\topsep{0pt}%
    \addtolength{\leftmargin}{#1}
    \setlength\parsep{0pt plus 1pt}%
  }
  \item[]
}
{\end{list}}
%% Special footnote code from the package 'stblftnt.sty'
%% Author: Robin Fairbairns -- Last revised Dec 13 1996
\let\SF@@footnote\footnote
\def\footnote{\ifx\protect\@typeset@protect
    \expandafter\SF@@footnote
  \else
    \expandafter\SF@gobble@opt
  \fi
}
\expandafter\def\csname SF@gobble@opt \endcsname{\@ifnextchar[%]
  \SF@gobble@twobracket
  \@gobble
}
\edef\SF@gobble@opt{\noexpand\protect
  \expandafter\noexpand\csname SF@gobble@opt \endcsname}
\def\SF@gobble@twobracket[#1]#2{}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Textclass specific LaTeX commands.
 \newenvironment{lyxlist}[1]
   {\begin{list}{}
     {\settowidth{\labelwidth}{#1}
      \setlength{\leftmargin}{\labelwidth}
      \addtolength{\leftmargin}{\labelsep}
      \renewcommand{\makelabel}[1]{##1\hfil}}}
   {\end{list}}
 \newenvironment{lyxcode}
   {\begin{list}{}{
     \setlength{\rightmargin}{\leftmargin}
     \raggedright
     \setlength{\itemsep}{0pt}
     \setlength{\parsep}{0pt}
     \verbatim@font}%
    \item[]}
   {\end{list}}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% User specified LaTeX commands.
\hyphenpenalty=10000

\makeatother

\begin{document}


\title{ABILITÀ INFORMATICHE PER CHIMICI (2002/2003)\\
Introduzione a UNIX}


\author{Dr. Giorgio Signorini\\
Dipartimento di Chimica (stanza 326, tel 055-457-3085, \texttt{giorgio.signorini@unifi.it})\\
\texttt{http://www.chim.unifi.it/\~{}signo/did/unix}}

\maketitle

\section{Organizzazione del modulo}

\vspace{0.3cm}
{\centering \begin{tabular}{|c|c|c|c|c|c|}
\hline 
&
LU&
MA&
ME&
GI&
VE\\
\hline 
\hline 
8:30-10:00&
&
&
&
\textbf{2, 3}&
\\
\hline 
10:30-12:30&
&
&
\textbf{lezione}&
&
\\
\hline 
&
&
&
&
&
\\
\hline 
14:00-15:30&
&
\textbf{}&
\textbf{}&
\textbf{3, 1}&
\\
\hline 
15:30-17:00&
&
\textbf{}&
\textbf{}&
\textbf{1, 2}&
\\
\hline 
\end{tabular}\par}
\vspace{0.3cm}

\vspace{0.3cm}
{\centering \begin{tabular}{|c|c|}
\hline 
\textbf{lezione}&
\textbf{Esercitazione}\\
\hline 
\hline 
4/12/2002&
5/12\\
\hline 
11/12/2002&
12/12\\
\hline 
\end{tabular}\par}
\vspace{0.3cm}

\newpage
\tableofcontents{}


\newpage
\section{Argomenti generali}


\subsection{Introduzione e obiettivi}

UNIX è un ambiente di lavoro alternativo a Windows. Serve per compiere le principali
operazioni su un computer e eseguire programmi. 

È molto utilizzato in campo tecnico-scientifico, e particolarmente adatto per
macchine che devono fare da \emph{server} (es. nei siti WWW: vedi \url{http://leb.net/hzo/ioscount/}
oppure \url{http://econ.csuchico.edu/~harrison/k12linux/}). 

A differenza di Windows, UNIX non è un prodotto commerciale; e più simile ad
una lingua. Esitono molti {}``dialetti{}'' UNIX: il più diffuso è Linux, che
funziona sui PC. 

Obiettivo di questo modulo è mettere in grado gli studenti di lavorare con UNIX
in modo elementare: operare su un terminale ASCII dando semplici comandi per
gestire file, creare ed editare file, elaborare file di dati, ed usare semplici
applicazioni. 


\subsection{Sistemi Operativi}

Il S.O. è il s/w di basso livello e di uso generale che 

\begin{itemize}
\item permette di gestire tutte le risorse del calcolatore:

\begin{itemize}
\item dischi e spazio disco
\item CPU e esecuzione programmi
\item dispositivi di ingresso/uscita
\item periferiche
\item ...
\end{itemize}
\item interagisce con

\begin{itemize}
\item utenti
\item programmi applicativi
\end{itemize}
\end{itemize}
Notare bene la differenza tra SO e programmi applicativi. Ad es: OpenOffice.org
è un programma applicativo che funziona sia su Windows che su Linux. 

A sua volta il SO è distinto in vari strati

\begin{itemize}
\item kernel (nucleo di comandi fondamentali a cui si può rivolgere direttamente un
programma, ma di solito non l'utente)
\item comandi (es. \texttt{ls}) e programmi basilari (es. un editor)
\item interfacce utente: testuali (es shell) e grafiche (GUI)
\end{itemize}

\subsubsection{S. O. : grafici esplicativi, definizione, esempi}


\begin{figure}
{\par\centering \includegraphics{lez.fig-kern.ps} \par}


\caption{vari strati di \emph{software} tra utenti e \emph{hardware} in \emph{}un tipico
ambiente UNIX}
\end{figure}

\begin{figure}

\caption{un'altra rappresentazione degli strati di software in UNIX}

{\par\centering \includegraphics{tlayers.ps} \par}
\end{figure}


\begin{quotation}
{[}Free OnLine Dic Of Computing{]}:

operating system:

The low-level software which handles the interface to peripheral hardware, schedules
tasks, allocates storage, and presents a default interface to the user when
no application program is running.

The OS may be split into a kernel which is always present and various system
programs which use facilities provided by the kernel to perform higher-level
house-keeping tasks, often acting as servers in a client-server relationship.

Some would include a graphical user interface and window system as part of the
OS, others would not. The operating system loader, BIOS, or other firmware required
at boot time or when installing the operating system would generally not be
considered part of the operating system, though this distinction is unclear
in the case of a rommable operating system such as RISC OS.

The facilities an operating system provides and its general design philosophy
exert an extremely strong influence on programming style and on the technical
cultures that grow up around the machines on which it runs.

Example operating systems include 386BSD, AIX, AOS, Amoeba, Angel, Artemis microkernel,
BeOS, Brazil, COS, CP/M, CTSS, Chorus, DACNOS, DOSEXEC 2, GCOS, GEORGE 3, GEOS,
ITS, KAOS, Linux, LynxOS, MPV, MS-DOS, MVS, Mach, Macintosh operating system,
MINIX, Multics, Multipop-68, Novell NetWare, OS-9, OS/2, Pick, Plan 9, QNX,
RISC OS, STING, System V, System/360, TOPS-10, TOPS-20, TRUSIX, TWENEX, TYMCOM-X,
Thoth, Unix, VM/CMS, VMS, VRTX, VSTa, VxWorks, WAITS, Windows 3.1, Windows 95,
Windows 98, Windows NT.
\end{quotation}

\subsection{Interfacce utente}

Servono per permettere all'utente di svolgere operazioni comuni, ad es., spostare
un file da una directory all'altra o lanciare un programma. In UNIX si hanno

\begin{itemize}
\item interfaccia testuale (sempre):

\begin{itemize}
\item si ha a disposizione una riga dove si possono scrivere comandi.
\item la \emph{riga di comando} è interpretata da una \emph{shell}: piccolo ambiente
di programmazione (variabili, controllo di flusso etc.), che prepara il comando
da passare al SO vero e proprio; in uno stesso UNIX si possono usare diverse
shell con caratteristiche leggermente diverse tra loro
\item sullo schermo compaiono eventuali risultati (output) del comando in formato
testo
\end{itemize}
\item interfaccia grafica (componente \emph{non essenziale}): 

\begin{itemize}
\item X-windows (solo gestione della parte formale: cornici, bottoni, menu)
\item Scrivania (menu avvio, barre, strumenti tipo file manager)
\item contiene un terminale dove si può lavorare con interfaccia testuale; dal terminale
si possono lanciare comandi che aprono nuove finestre
\end{itemize}
\end{itemize}
Le varie interfacce grafiche sono simili tra loro, e in sostanza simili a Windows
o al sistema MacIntosh, e come tali abbastanza intuitive; ciò che caratterizza
UNIX rispetto agli altri S.O. è invece l'interfaccia testuale. Noi lavoreremo
con quest'ultima (il \emph{terminale}), all' interno di quella grafica. 

\begin{itemize}
\item vantaggi dell'interfaccia testuale

\begin{itemize}
\item si hanno a disposizione molti più comandi di quanti non possano contenerne i
menu
\item si possono combinare più comandi in una {}``frase{}'' . 
\end{itemize}
Ad es:

\begin{quote}
\texttt{grep Error /var/log/httpd/access.log | wc -l }
\begin{quote}
esamina il file di statistiche del server HTTP selezionando le righe che contengono
la parola {}``\texttt{Error}{}'' (primo comando, fino alla {}``\texttt{|}{}''
) e poi le conta (secondo comando).
\end{quote}
\end{quote}
\end{itemize}

\subsection{Caratteristiche di UNIX}

Caratteristiche di UNIX rispetto ad altri Sistemi Operativi: 

\begin{itemize}
\item multi-utente
\item multi-processo
\item \char`\"{}filosofia\char`\"{} = attrezzi (efficienti), combinabili
\end{itemize}
Insieme alle componenti fondamentali del sistema operativo, in UNIX si trovano
sempre

\begin{itemize}
\item connettività in rete (TCP/IP)
\item ambiente grafico (X-window system)
\end{itemize}

\subsection{vantaggi e svantaggi di UNIX su Windows}

cfr \url{http://www.attivissimo.net/w2l1/03.htm}

\begin{itemize}
\item vantaggi

\begin{description}
\item [potenza:]permette di fare più cose (adatto a fare da {}``server{}'')
\item [stabilità,~sicurezza~,trasparenza:]si blocca meno; maggiore resistenza ai
virus; migliore protezione (permessi di scrittura ed esecuzione); controllo
totale (codice sorgente {}``aperto{}'')
\item [prezzo:]molte versioni di UNIX sono {}``libere{}''; Linux si può copiare
\emph{legalmente}.
\end{description}
\item svantaggi

\begin{description}
\item [sforzo~iniziale:]ci vuole un po' di tempo per impararlo
\item [minore~offerta~di~programmi:]non adatto se dovete assolutamente usare un
programma in particolare
\item [aggiornamento~hardware:]è difficile far funzionare un componente hardware
di recente produzione
\end{description}
\end{itemize}

\subsection{sw libero}

In genere, si intende s/w libero = senza diritti d'autore (si può copiare legalmente)

Dibattito: 

\begin{itemize}
\item alcuni pensano: siccome gli autori non possono guadagnarci, il s/w libero è
di bassa qualità
\item secondo altri: se gli strumenti intellettuali non sono coperti da diritto d'autore
(es. ricerca scientifica, definizioni di standard, etc. ) il loro sviluppo è
più rapido ed efficiente; a differenza della proprietà materiale, la proprietà
intellettuale può essere remunerativa anche se non è esclusiva
\end{itemize}
Di fatto:

\begin{itemize}
\item i prodotti di maggior successo negli ultimi anni (TCP/IP, WWW, UNIX) sono privi
di copyright
\item la rinuncia alla segretezza dei codici sorgente è una strategia sempre più adottata
per lo sviluppo del s/w (Mozilla, OpenOffice.Org)
\end{itemize}
Aspetto fondamentale: per favorire lo sviluppo, non è tanto importante che il
s/w sia gratuito, quanto che sia modificabile (codice sorgente aperto)


\subsubsection{definizione di software libero }

\emph{(Basato su \cite{AppuntiInfoLibera} e http://www.gnu.org/philosophy/free-sw.html)}

Secondo la definizione più diffusa, è \char`\"{}libero\char`\"{} il s/w che
permette a chiunque di: 

\begin{enumerate}
\item usarlo;
\item studiare come funziona (accesso al codice);
\item ridistribuirlo;
\item modificarlo e distribuirlo modificato
\end{enumerate}
Altre definizioni:

\begin{description}
\item [s/w~di~dominio~pubblico]= senza copyright né licenza (qualcuno può \char`\"{}appropriarsene\char`\"{})
\item [copyleft]= licenza che garantisce diritti di s/w libero, ma impone di mantenerlo
libero (controesempio: X11, è distribuito con licenza libera, ma non impedisce
restrizioni- alcune versioni sono a pagamento e sono le uniche a funzionare
su un certo h/w)
\item [GNU~Public~License~(GPL)]= particolare licenza con \emph{copyleft} che permette
anche l'uso commerciale del s/w
\item [s/w~semi-libero]= s/w libero, ma senza permesso di trarne profitto 
\item [freeware]= s/w gratuito, spesso senza sorgente
\item [shareware]= s/w gratuito per tempo limitato
\begin{figure}

\caption{vari tipi di software libero}

{\par\centering \includegraphics{lez.fig-freesw.ps} \par}
\end{figure}

\end{description}

\subsection{UNIX come famiglia di sistemi operativi, liberi e non}

Ci sono vari {}``dialetti{}'' UNIX, catalogabili in due gruppi:

\begin{itemize}
\item UNIX commerciali (generalmente contengono almeno una parte dell'originale sorgente
AT\&T, e la relativa licenza)
\item UNIX (più o meno) liberi: FreeBSD, NetBSD, ... (quelli con GPL sono: Linux,
Hurd)
\end{itemize}
Note:

\begin{enumerate}
\item UNIX è un marchio registrato

\begin{quote}
\char`\"{}UNIX® is a registered trademark of The Open Group\char`\"{}\char`\"{}
\end{quote}
però di fatto si è trasformato in uno standard; è proprietà di un'organizzazione
più interessata agli standard industriali che alla proprietà intellettuale.
Ci sono test passati i quali un S.O. può dirsi legalmente UNIX.

\item Esiste uno standard {}``puro{}'': POSIX. Praticamente, un sottoinsieme di
UNIX®

\begin{quotation}
POSIX (Portable Operating System Interface):

A set of IEEE standards designed to provide application portability between
Unix variants. IEEE 1003.1 defines a Unix-like operating system interface, IEEE
1003.2 defines the shell and utilities and IEEE 1003.4 defines real-time extensions.
\end{quotation}
\end{enumerate}

\subsubsection{breve storia di UNIX}

1969 Thompson (Bell Laboratories, NJ, USA)

Principali famiglie di discendenti (anni '80-'90):

\vspace{0.3cm}
{\centering \begin{tabular}{lll}
SystemV&
(AT\&T)&
commerciale, solida\\
BSD&
(Università Berkeley) &
non-commerciale, dinamica\\
\end{tabular}\par}
\vspace{0.3cm}

BSD deriva da versioni date alle Università per scopi di studio, compreso il
codice sorgente. Dal 1993 c'è versione (4.4BSD Lite) ripulita dal codice proprietario
AT\&T.

\begin{quotation}
{[}AIL{]}

I primi utenti di UNIX sono state le università, a cui in particolare questo
sistema operativo veniva fornito a costo contenuto, ma senza alcun tipo di supporto
tecnico, né alcuna garanzia. Proprio questa assenza di sostegno da parte della
casa che lo aveva prodotto, stimolava la cooperazione tra gli utenti competenti,
in pratica tra le università.

Il maggior fermento intorno a UNIX si concentrò presso l'università della California
a Berkeley, dove a partire dal 1978 si cominciò a distribuire una variante di
questo sistema operativo: BSD (Berkeley Software Distribution).

Per difendere il software prodotto in questo modo, nacque una licenza d'uso
che rimane il progenitore della filosofia del software libero: la licenza BSD.

Per molto tempo, la variante BSD di UNIX rimase relegata all'ambito universitario
o a quello di aziende che avevano acquistato i diritti per utilizzare il codice
sorgente dello UNIX originale. Ciò fino a quando si decise di ripulire lo Unix
BSD dal codice proprietario.

Il risultato iniziale fu 386BSD, che venne rilasciato nel 1992 con la versione
0.1. {[}...{]} si svilupparono altri progetti indipendenti per ottenere, finalmente,
un sistema BSD libero. Il primo di questi fu nominato NetBSD, al quale si aggiunse
subito dopo FreeBSD; più tardi, apparve anche OpenBSD.

{[}...{]}

Allo stato attuale, le tre varianti {*}BSD sono tutte riconducibili a BSD 4.4-Lite,
dove le differenze più importanti riguardano le piattaforme hardware in cui
possono essere installate e l'origine della distribuzione. Infatti, il punto
di forza della variante OpenBSD, sta nel fatto di essere realizzata in Canada,
da dove possono essere distribuiti anche componenti per la comunicazione crittografica.
\end{quotation}
Negli anni '90 dal punto di vista del linguaggio le due famiglie (BSD e SysV)
si sono avvicinate. 


\subsection{Linux}

Linux è un Sistema Operativo della famiglia UNIX con le seguenti caratteristiche:

\begin{itemize}
\item libero (GPL)
\item POSIX
\end{itemize}
\begin{description}
\item [{}``distribuzione{}''~Linux:]Linux kernel + comandi, shell + TCP/IP + X11
+ Desktop Manager + ... 
\end{description}
Sono a pagamento: (eventualmente) qualche {}``abbellimento{}'' s/w non essenziale,
la commercializzazione, la guida stampata, i CD. 

Esempi di distribuzioni Linux:

\begin{itemize}
\item Debian
\item Caldera
\item RedHat
\item Slackware
\item SuSE
\item ...
\end{itemize}
Nelle esercitazioni useremo RedHat 7.2. 


\subsection{GNU}

GNU è un insieme di strumenti di s/w libero (comandi, shell, applicazioni) da
usare {}``sopra{}'' un kernel UNIX:~ GNU/Hurd (Sistema Operativo composto
dal kernel Hurd e da GNU), GNU/Linux

È un {}``progetto{}'' creato dalla Free Software Foundation (FSF)

\begin{quotation}
Da {[}AIL{]}:

Nel 1985, Richard Stallman ha fondato la FSF, Free Software Foundation, con
lo scopo preciso di creare e diffondere la filosofia del «software libero».
Libertà intesa come la possibilità data agli utenti di distribuire e modificare
il software a seconda delle proprie esigenze e di poter distribuire anche le
modifiche fatte.

Queste idee filosofiche si tradussero in pratica nella redazione di un contratto
di licenza d'uso, la General Public License, studiato appositamente per proteggere
il software libero in modo che non potesse essere accaparrato da chi poi avrebbe
potuto impedirne la diffusione libera. Per questo motivo, oggi, il copyright
di software protetto in questo modo, viene definito copyleft.

Il software libero richiede delle basi, prima di tutto il sistema operativo.
In questo senso, l'obiettivo pratico che si prefiggeva Richard Stallman era
quello di realizzare, con l'aiuto di volontari, un sistema operativo completo.

Nacque così il progetto GNU (Gnu's Not Unix), con il quale, dopo la realizzazione
di un compilatore C, si volevano costruire una serie di programmi di servizio
necessari nel momento in cui il cuore del sistema fosse stato completo.

Il progetto GNU diede vita così a una grande quantità di software utilizzabile
sulla maggior parte delle piattaforme Unix, indirizzando implicitamente il software
libero nella direzione dei sistemi di questo tipo.

Nel 1990 inizia lo sviluppo del kernel Hurd e intorno al 2000 inizia la distribuzione
del sistema GNU/Hurd (sistema GNU basato su kernel Hurd).
\end{quotation}

\newpage
\section{UNIX: nozioni fondamentali}


\subsection{navigazione nel \emph{filesystem} e gestione elementare di file e directory}

\emph{NOTA: i comandi che appaiono sottolineati, come} \texttt{\emph{\underbar{less}}}\emph{,}
\texttt{\emph{\underbar{}}}\emph{non sono UNIX, ma estensioni GNU che comunque
si trovano nella maggior parte delle distribuzioni di Linux}


\subsubsection{\texttt{login}, \texttt{logout} e \texttt{exit}; sintassi di un comando; il
comando \texttt{passwd}}

\begin{itemize}
\item maiuscole e minuscole sono diverse!
\item la shell: invito ai comandi (\emph{prompt})
\item sintassi di un comando:

\begin{itemize}
\item una riga di comando è ciò che si digita al prompt, fino al tasto <invio> (o
fino al primo {}``\texttt{;}{}'')
\item la riga di comando è costituita di parole separate da uno o più spazi
\item la sintassi di un comando è sempre
\end{itemize}
\begin{quote}
\texttt{\emph{comando {[}opzioni{]} argomento1 argomento2 ...}}
\end{quote}
\begin{description}
\item [\texttt{\emph{comando:}}]la prima parola
\item [\texttt{\emph{opzioni:}}](o \emph{switch}) parole che cominiciano con il carattere
{}``\texttt{-}{}'' e stanno tra comando e argomenti (cambiano il comportamento
del comando)
\item [\texttt{\emph{argomenti:}}]tutte le parole dopo il comando e le eventuali opzioni 
\end{description}
Es: 

\begin{quote}
\texttt{date}~\\
\texttt{date -u}~\\
\texttt{grep Rossi elenco.txt}~\\
\texttt{grep -i Rossi elenco.txt}~\\
\texttt{tar -{}-help}
\end{quote}
\item un comando importante: \texttt{passwd} (oppure \texttt{yppasswd)}
\item \texttt{logout~~}e~~\texttt{exit}


\texttt{exit} è il comando generico di uscita dalla shell (funziona sempre);
\texttt{logout} fa uscire solo da shell di login. 

\end{itemize}

\newpage
\subsubsection{utenti e gruppi; \texttt{who} e \texttt{finger}}

\begin{itemize}
\item si accede sempre come un utente
\item utenti hanno accesso differenziato a diverse risorse 
\item utenti sono riuniti in gruppi; anche i gruppi hanno accesso differenziato a
risorse
\item l'utente \emph{root} (=radice) ha tutti gli accessi: serve per gestione sistema
(non lo trattiamo qui)
\item un utente ha:

\begin{itemize}
\item nome
\item password
\item gruppo di appartenenza
\item (nome reale)
\item directory di partenza (\emph{home} \emph{directory}); in generale, per l'utente
\texttt{tizio}, è 
\end{itemize}
\begin{quote}
\texttt{/home/tizio}
\end{quote}
\begin{itemize}
\item shell di partenza
\end{itemize}
\end{itemize}
Esempi:

\begin{itemize}
\item \texttt{who}
\item \texttt{finger, finger} \texttt{\emph{utente}}


\texttt{finger} fa vedere gli utenti collegati, in un modo simile a \texttt{who};
con \texttt{finger} \texttt{\emph{utente}} si ottengono informazioni su qualunque
utente, anche se non collegato

\end{itemize}

\newpage
\subsubsection{file e directory; directory corrente e directory genitrice;\texttt{ls}, \texttt{pwd}
e \texttt{cd}}

\begin{itemize}
\item il file è l'unità fondamentale di informazione dal punto di vista del sistema
operativo: 


può essere un documento, un insieme di dati in forma binaria, un programma

\item i file sono organizzati in un sistema a directory ramificato che parte da una
radice

\begin{quotation}
\texttt{~~~~~~~ ramo}

\texttt{~~~~~~ .-{}-{}-{}-{}->o}

\texttt{~~~~~~ |~~~~~~~~~~~ .-{}-{}-{}-{}-{}->o}

\texttt{~~~~~~ |~~~ ramo~~~ |}

\texttt{radice o-{}-{}-{}-{}-{}-{}-{}-{}-{}-{}->o-{}-{}-{}-{}-{}-{}-{}->o nodo}

\texttt{~~~~~~ | }

\texttt{~~~~~~ `-{}-{}-{}-{}-{}-{}->o nodo}
\end{quotation}
~

ogni nodo può essere terminale (file) o ramificato (directory); 

in altre parole, una directory può contenere 

\begin{itemize}
\item file
\item (sotto-)directory
\end{itemize}
\item in ogni momento ci si trova su una directory (la directory \emph{corrente}):
per sapere quale, dare

\begin{quote}
\texttt{pwd}
\end{quote}
per conoscere il contenuto della directory corrente, dare {\selectlanguage{american}}

\begin{quote}
\texttt{ls}
\end{quote}
\item per cambiare directory, dare {\selectlanguage{american}}

\begin{quote}
\texttt{cd} \texttt{\emph{nuovadirectory}}
\end{quote}
in particolare, per andare alla directory {}``genitrice{}'' (=sopra la corrente,
cioè all'indietro verso la radice):

\begin{quote}
\texttt{cd ..}
\end{quote}
\end{itemize}

\newpage
\subsubsection{percorso assoluto e relativo}


\begin{figure}
{\par\centering \includegraphics{directory-tree.eps} \par}


\caption{esempio di percorsi}
\end{figure}


In UNIX ogni oggetto (file o directory) può essere sempre identificato in tre
modi:

\begin{enumerate}
\item se si trova sulla \textbf{directory corrente}, con il semplice nome (es. \texttt{pippo}
o \texttt{gigi})
\item se \textbf{non} si trova sulla directory corrente, facendo precedere il nome
dal \textbf{percorso} da compiere \textbf{}(cioè la sequenza di directory da
attraversare) per arrivare all'oggetto. Il percorso (\emph{path}) può essere
specificato in modo

\begin{enumerate}
\item \textbf{relativo:} cioè a partire dalla directory corrente. In questo caso,
il nome \textbf{non} comincia mai con la barra (\texttt{/}). 


es: se ci si trova sulla directory \texttt{/home/tizio/}, il primo file si chiama

\begin{quote}
\texttt{ese/pippo}
\end{quote}
\item \textbf{assoluto:} a partire dalla radice (\texttt{/}). In questo caso, il nome
comincia sempre con la barra. 


es: il percorso assoluto per i due file evidenziati è, rispettivamente:

\begin{quote}
\texttt{/home/tizio/ese/pippo}

\texttt{/home/infochim/wrk/e3/gigi}
\end{quote}
\end{enumerate}
\end{enumerate}

\newpage
\subsubsection{le directory~{}''.{}'', ~{}''..{}'' ~e~{}''\texttt{\~{}}{}'' ; }

Ci sono dei nomi speciali di directory:

\begin{lyxlist}{00.00.0000}
\item [\texttt{..}]la directory \char`\"{}genitrice\char`\"{} (l'abbiamo già vista
nel comando \texttt{cd})
\item [\texttt{.}]la directory corrente
\item [\texttt{\~{}}]la mia home directory
\item [\texttt{\~{}tizio}]la home directory dell'utente \texttt{tizio}
\end{lyxlist}
Esempi:

\vspace{0.3cm}
{\centering \begin{tabular}{|l|l|}
\hline 
\emph{directory corrente}&
\emph{nome del file}\\
\hline 
\hline 
\emph{(qualunque)}&
\texttt{/home/tizio/ese/pippo}\\
\hline 
\texttt{/home/tizio/ese/}&
\texttt{pippo}\\
\hline 
\texttt{/home/tizio/}&
\texttt{ese/pippo}\\
\hline 
\hline 
\texttt{/home/tizio/ese/}&
\texttt{./pippo}\\
\hline 
\texttt{/home/caio}&
\texttt{../tizio/ese/pippo}\\
\hline 
\hline 
\emph{(qualunque; utente=} \texttt{\emph{tizio}}\emph{)}&
\texttt{\~{}}\texttt{/ese/pippo}\\
\hline 
\emph{(qualunque; utente=} \texttt{\emph{caio}}\emph{)}&
\texttt{\~{}}\texttt{tizio/ese/pippo}\\
\hline 
\end{tabular}\par}
\vspace{0.3cm}

Notare che

\begin{itemize}
\item \texttt{.~~..~~\~{}}~~sono directory diverse a seconda di dove ci si trova
e di che utente siamo.
\item riferirsi a un file come \texttt{\emph{./pippo}} o come \texttt{\emph{pippo}}
è identicamente la stessa cosa.
\end{itemize}

\newpage
\subsubsection{lista di una directory diversa dalla directory corrente: \texttt{ls} \texttt{\emph{dir}}}

Il comando

\begin{quote}
\texttt{ls} \texttt{\emph{dir}}
\end{quote}
dà la lista dei file contenuti nella directory \texttt{\emph{dir}}. 

Note

\begin{enumerate}
\item La stessa cosa si può ottenere portandosi sulla directory e dando il comando
\texttt{ls:}

\begin{quote}
\texttt{cd} \texttt{\emph{dir}}

\texttt{ls}
\end{quote}
\item Un comando equivalente a \texttt{ls} è

\begin{quote}
\texttt{ls . }
\end{quote}
\end{enumerate}

\subsubsection{nomi di file e directory; file e directory nascosti; \texttt{ls -a}}

\begin{itemize}
\item nomi dei file e directory: non c'è alcuna limitazione vera e propria, ma sono
assolutamente da evitare caratteri che hanno significato speciale: spazi, \texttt{/\textasciitilde{}!@\#\$\%\textasciicircum{}\&{*}({[}\{\}{]})<>'}
etc. Caratteri permessi: \texttt{ABC...Z, abc...z} {}``\_{}'', {}``-{}``
{}``.{}'' 

\begin{itemize}
\item notare che in Windows si fa largo uso di spazi nel nome di un file; in UNIX
gli spazi separano parole, cioè argomenti diversi di un comando
\end{itemize}
\item il carattere iniziale \char`\"{}.\char`\"{}: directory e file \char`\"{}nascosti\char`\"{}; 


si possono vedere con l'opzione \texttt{-a} di \texttt{ls}: \texttt{}

\begin{quote}
\texttt{ls -a}
\end{quote}
\end{itemize}

\newpage
\subsubsection{permessi di lettura, scrittura ed esecuzione dei file; \texttt{ls -l}}

\begin{itemize}
\item ogni file appartiene ad un utente e a un gruppo
\item permessi: 


ogni file può avere il permesso di

\begin{itemize}
\item lettura (\texttt{r})
\item scrittura (\texttt{w})
\item esecuzione (\texttt{x})
\end{itemize}
e questi permessi possono essere in relazione a

\begin{itemize}
\item utente
\item gruppo
\item tutti gli altri
\end{itemize}
si esprimono con una stringa di nove caratteri:

\end{itemize}
\vspace{0.3cm}
{\centering \begin{tabular}{|c|c|c|c|c|c|c|c|c|c|}
\hline 
Permesso&
\multicolumn{3}{|c|}{utente {\selectlanguage{american}}}&
\multicolumn{3}{|c|}{gruppo {\selectlanguage{american}}}&
\multicolumn{3}{|c|}{altri {\selectlanguage{american}}}\\
\hline 
\hline 
sì &
\texttt{r}&
\texttt{w}&
\texttt{x}&
\texttt{r}&
\texttt{w}&
\texttt{x}&
\texttt{r}&
\texttt{w}&
\texttt{x}\\
\hline 
\hline 
no&
\texttt{-}&
\texttt{-}&
\texttt{-}&
\texttt{-}&
\texttt{-}&
\texttt{-}&
\texttt{-}&
\texttt{-}&
\texttt{-}\\
\hline 
\end{tabular}\par}
\vspace{0.3cm}

Utente e gruppo di appartenenza, e permessi dei file, si possono visualizzare
con il comando 

\begin{quote}
\texttt{ls -l}

Es:

\texttt{\textbf{-rw-r-{}-r-{}-}} \texttt{1} \texttt{\textbf{infochim chimica}}
\texttt{6661 Nov 12 15:30} \texttt{\textbf{Mailbox}}

significa: leggibile e scrivibile, ma non eseguibile, dall'utente (\texttt{infochim)};
solo leggibile dagli appartenti al gruppo (\texttt{chimica}); solo leggibile
da tutti gli altri

\end{quote}
Notare che la stringa dei permessi contiene 10 caratteri: il primo indica (fra
l'altro) se si tratta di una directory, nel qual caso compare una \texttt{d}

Le altre informazioni che vengono stampate con questo comando (le ultime colonne
prima del nome del file) sono la data e l'ora di ultima modifica del file. 

N.B. si possono combinare le opzioni \texttt{-l} e \texttt{-a}, in uno qualunque
dei seguenti modi

\begin{quote}
\texttt{ls -l -a}

\texttt{ls -a -l }

\texttt{ls -la }

\texttt{ls -al}
\end{quote}

\subsubsection{comandi per gestire file: \texttt{cp, mv, rm}}

\begin{description}
\item [\texttt{rm}]rimuove (cancella)
\item [\texttt{cp}]copia
\item [\texttt{mv}]sposta (rinomina)
\end{description}
Notare il comportamento di \texttt{cp} e \texttt{mv:} 

\begin{itemize}
\item la sintassi è:
\end{itemize}
\begin{quote}
\texttt{\emph{comando origine ... destinazione}}
\end{quote}
\begin{itemize}
\item si comportano in modo diverso a seconda che \texttt{\emph{destinazione}} sia
un file o una directory. Ad esempio:
\end{itemize}
\vspace{0.3cm}
{\centering \begin{tabular}{|c|c|}
\hline 
\emph{riga di comando}&
\emph{spiegazione}\\
\hline 
\hline 
\texttt{cp file1 file2}&
copia \texttt{file1} in \texttt{file2}\\
\hline 
\texttt{cp file1 dir}&
copia \texttt{file1} in \texttt{dir/file1}\\
\hline 
\texttt{cp file1 file2 ... dir}&
copia \texttt{file1, file2, ...} in \texttt{dir/file1, dir/file2, ...}\\
\hline 
\end{tabular}\par}
\vspace{0.3cm}


\subsubsection{comandi per gestire directory: \texttt{mkdir} e \texttt{rmdir}}

\begin{itemize}
\item per creare una directory:
\end{itemize}
\begin{quote}
\texttt{mkdir} \texttt{\emph{directory}}
\end{quote}
\begin{itemize}
\item per rimuovere una directory:
\end{itemize}
\begin{quote}
\texttt{rmdir} \texttt{\emph{directory}}

per poterla rimuovere, la directory deve essere vuota 
\end{quote}

\subsubsection{vedere il contenuto di un file: \texttt{cat, more, less}}

\begin{itemize}
\item per visualizzare sullo schermo il contenuto di un file:

\begin{quote}
\texttt{cat file}
\end{quote}
\item lo stesso, ma una schermata per volta:

\begin{quote}
\texttt{more file}
\end{quote}
\item lo stesso,con la possibilità di scorrere anche all'indietro:

\begin{quote}
\texttt{\underbar{less}} \texttt{file}
\end{quote}
\end{itemize}

\subsubsection{cambiare il contenuto di un file: gli editor di testo \texttt{vi} e \texttt{emacs}}

\begin{itemize}
\item editor di testo: sono adatti per editare file di testo non formattati, come
programmi, semplici liste, etc; documenti formattati in genere contengono istruzioni
di formattazione codificate (es. MS Word) e possono essere modificati solo dal
programma che li ha creati o da uno compatibile. Controesempio: documenti in
HTML, le istruzioni di formattazione sono scritte in chiaro
\item \texttt{vi} è un editor di testo rudimentale, scomodo da usare. Vantaggio: 

\begin{itemize}
\item fa parte del S. O. , lo trovate sempre
\item può essere usato in condizioni di ristrettezza di risorse (es. collegamento
remoto)
\end{itemize}
\item \texttt{\underbar{emacs}} è un programma GNU; è il miglior editor di testo disponibile.
In ambiente grafico apre una finestra a sè con barra dei menu e funzionamento
abbastanza intuitivo


per editare un file: 

\begin{quote}
\texttt{\underbar{emacs}} \texttt{file}
\end{quote}
\end{itemize}

\subsubsection{manuali}

\begin{lyxlist}{WHATISSCOMANDO}
\item [\texttt{man~}\texttt{\emph{comando}}]guida esauriente su comando (qualche
pagina)
\item [\texttt{whatis~}\texttt{\emph{comando}}]definizione (una riga)
\item [\texttt{apropos~}\texttt{\emph{xxx}}]lista di comandi che hanno a che vedere
con l'argomento xxx
\end{lyxlist}
Es: 

\begin{lyxcode}
man~passwd;~whatis~ls;~apropos~calendar
\end{lyxcode}

\newpage
\subsection{proprietà delle shell}

queste sono proprietà per lo più comuni a tutte le shell


\subsubsection{reindirizzamento di input e output, pipeline}

In UNIX, i dati prodotti da un comando sono detti \emph{standard~output} e
quelli forniti al comando sono detti \emph{standard~input}. Questi flussi di
dati in generale sono associati così:

\vspace{0.3cm}
{\centering \begin{tabular}{|c|c|}
\hline 
\textbf{\emph{standard~input}} &
tastiera\\
\hline 
\textbf{\emph{standard~output}} &
video\\
\hline 
\end{tabular}\par}
\vspace{0.3cm}

Si possono associare input e output a file normali con la seguente sintassi

\vspace{0.3cm}
{\centering \begin{tabular}{|l|l|}
\hline 
\texttt{\emph{comando}}\texttt{~>~}\texttt{\emph{file}} &
esegui \texttt{\emph{comando}} e dirigi output su \texttt{\emph{file}}\\
\hline 
\texttt{\emph{comando~<}}\texttt{~}\texttt{\emph{file}} &
esegui \texttt{\emph{comando}} prendendo input da \texttt{\emph{file}}\\
\hline 
\texttt{\emph{comando1~}}\texttt{|~}\texttt{\emph{comando2~~~~~}}&
l'output di \texttt{\emph{comando1}} diventa input di \texttt{\emph{comando2}}\\
\hline 
\texttt{\emph{comando}}\texttt{~>\textcompwordmark{}>~}\texttt{\emph{file}}
&
aggiungi output di \texttt{\emph{comando}} in coda a \texttt{\emph{file}}\\
\hline 
\end{tabular}\par}
\vspace{0.3cm}

{\par\raggedright Esempio:\par}

~

{\raggedright \begin{tabular}{ll}
\texttt{date}&
\emph{~~~~~~~~~~~~~~~~~~~~~~~~~~~~ stampa la data
e l'ora}\\
\texttt{date > a.000}&
\emph{~~~~~~~~~~~~~~~~~~~~~~~~~~~~ mette il risultato
nel file} \texttt{a.000}\\
\texttt{wc -w < a.000}&
\emph{~~~~~~~~~~~~~~~~~~~~~~~~~~~~ conta le parole
nel file} \texttt{a.000}\\
\end{tabular}\par}

~

Gli ultimi due comandi possono essere combinati in una \emph{pipeline}, senza
passare attraverso il file \texttt{a.000}:

\vspace{0.3cm}
{\raggedright \begin{tabular}{ll}
\texttt{date | wc -w}&
\emph{~~~~~~~~~~~~~~~~~~~~~~~~~~~~ conta le parole
nell'output di} \texttt{date}\\
\end{tabular}\par}
\vspace{0.3cm}

Nota: una \emph{pipeline} può essere costituita da più di due comandi in fila:

\begin{quote}
\texttt{comando1 | comando2 | ... | comando99}
\end{quote}
e si può ridirigere l'input del primo comando e l'output dell'ultimo:

\begin{quote}
\texttt{comando1 < file1 | comando2 | ... | comando99 > file99}
\end{quote}

\subsubsection{esecuzione di comandi in serie, parallelo e \emph{background}; \texttt{ps}
e \texttt{jobs}}

Quando si dà un comando dal prompt, non è possibile dare ulteriori comandi finché
questo non è terminato. Dal prompt però si possono però dare due o più comandi
per volta:

\begin{description}
\item [esecuzione~in~serie:]per eseguire due comandi in successione (o serie):
\end{description}
\begin{quote}
\texttt{\emph{comando1}} \texttt{;} \texttt{\emph{comando2}}

Il sistema esegue \texttt{\emph{comando1}} , aspetta che sia terminato, poi
esegue \texttt{\emph{comando2}}
\end{quote}
\begin{description}
\item [esecuzione~in~parallelo:]per eseguire due comandi in contemporanea (o parallelo):
\end{description}
\begin{quote}
\texttt{\emph{comando1}} \texttt{\&} \texttt{\emph{comando2}}

Il sistema esegue \texttt{\emph{comando1}} e senza aspettare che sia terminato
esegue \texttt{\emph{comando}}2
\end{quote}
\begin{description}
\item [esecuzione~in\emph{~background:}]per eseguire un comando in sottofondo (\emph{background}):
\end{description}
\begin{quote}
\texttt{\emph{comando}} \texttt{\&} \texttt{\emph{}}

Il sistema esegue \texttt{\emph{comando}} in sottofondo e presenta il prompt
per nuovi comandi. 
\end{quote}
\begin{itemize}
\item L'esecuzione in parallelo può essere vista come un caso particolare di quest'ultimo,
in cui \texttt{\emph{comando1}} viene eseguito in \emph{background} e \emph{}\texttt{\emph{comando2}}
viene eseguito in superficie
\item Ogni comando che viene eseguito sulla macchina viene detto \textbf{\emph{processo}}
e ad esso è assegnato un numero d'ordine unico.


Per vedere tutti i processi, dare il comando \texttt{ps}. Esempio:

\begin{quote}
\texttt{\$ ps}~\\
\texttt{~ PID TTY~~~~~~~~~ TIME CMD}~\\
\texttt{17686 pts/3~~~ 00:00:00 tcsh}~\\
\texttt{18829 pts/3~~~ 00:00:00 ps}
\end{quote}
\item Una successione di uno o più processi lanciati con un unico comando (ad esempio,
una \emph{pipeline}) \emph{}viene detta \textbf{\emph{job}}. In particolare,
se il job è eseguito in \emph{background} ad esso è assegnato un numero d'ordine,
che è unico per una sessione di shell (p. es. un terminale). Il numero del job
viene scritto tra parentesi quadre sul terminale al momento che esso è lanciato.
Es:

\begin{quote}
\texttt{\$ emacs\& }

\texttt{{[}1{]} 10301}
\end{quote}
Il secondo numero che viene scritto è il numero di processo dell'ultimo processo
del job. 

Per vedere su terminale la lista di tutti i job, dare il comando \texttt{jobs}

\begin{quote}
\texttt{\$ cat gigafile | sort \& }~\\
\texttt{{[}2{]} 10334} {\selectlanguage{american}}

\texttt{\$ jobs}~\\
\texttt{{[}1{]}~ + Running~~~~~~~~~~~~~~~~~~~~~~ emacs}~\\
\texttt{{[}2{]}~ - Running~~~~~~~~~~~~~~~~~~~~~~ cat
gigafile | sort \& }
\end{quote}
\end{itemize}
\begin{quote}
Notare che ad ogni comando del job 2 (\texttt{cat} e \texttt{sort}) viene assegnato
un distinto numero di processo:
\begin{quote}
\texttt{\$ ps}~\\
\texttt{10284 pts/0~~~ 00:00:00 bash}~\\
\texttt{10301 pts/0~~~ 00:00:00 emacs}~\\
\texttt{10333 pts/0~~~ 00:00:00 cat}~\\
\texttt{10334 pts/0~~~ 00:00:00 sort}~\\
\texttt{10335 pts/0~~~ 00:00:00 ps}
\end{quote}
\end{quote}

\subsubsection{interruzione di processi}

\begin{description}
\item [Ctrl-C]arresta definitivamente il comando che si sta eseguendo
\item [Ctrl-Z]interrompe temporaneamente il comando che si sta eseguendo e rende il
prompt; per ripristinarlo:

\begin{itemize}
\item \texttt{fg} (lo ripristina in superficie o \emph{foreground})
\item \texttt{bg} (lo ripristina in \emph{background}) \texttt{}
\end{itemize}
\end{description}
Per arrestare definitivamente un processo in \emph{background} si usa il comando

\begin{quote}
\texttt{kill} \texttt{\emph{numero-processo}}
\end{quote}
oppure

\begin{quote}
\texttt{kill} \texttt{\emph{\%numero-job}}
\end{quote}

\subsubsection{sostituzioni: nomi di file}

Nei nomi di file si possono usare caratteri {}``jolly{}'': 

\vspace{0.3cm}
{\centering \begin{tabular}{|c|c|}
\hline 
\emph{carattere jolly} &
\emph{significato}\\
\hline 
\hline 
\texttt{{*}}&
 un qualunque numero di caratteri (anche nessuno) \\
\hline 
 \texttt{?}&
un solo carattere\\
\hline 
\texttt{{[}abc{]}}&
un solo carattere tra quelli citati tra parentesi\\
\hline 
\end{tabular}\par}
\vspace{0.3cm}

Esempi:

\vspace{0.3cm}
{\centering \begin{tabular}{|c|c|}
\hline 
\texttt{{*}.c} &
tutti i file che finiscono per \texttt{.c}\\
\hline 
\texttt{/etc/{*}}&
tutti i file della directory \texttt{/etc}\\
\hline 
\texttt{capitolo?.txt}&
\texttt{capitolo1.txt capitolo2.txt ...} (ma non \texttt{capitolo23.txt})\\
\hline 
\texttt{{[}ab{]}{*}}&
tutti file che cominciano per \texttt{a} o per \texttt{b}\\
\hline 
\end{tabular}\par}
\vspace{0.3cm}

La shell verifica quali file corrispondono all'espressione indicata e li sostituisce
\emph{pedissequamente} nella riga di comando, che poi esegue: differenza da
DOS! 

Esempio: supponiamo che la directory corrente contenga i file

\begin{quote}
\texttt{lettera.doc}~\\
\texttt{memo.txt}~\\
\texttt{riassunto.doc}~\\
\texttt{CV.doc}
\end{quote}
\begin{enumerate}
\item Il comando

\begin{quote}
\texttt{cp {*}.doc \~{}} \texttt{/backup-dir }
\end{quote}
si traduce nel comando 

\begin{quote}
\texttt{cp lettera.doc riassunto.doc CV.doc \~{}} \texttt{/backup-dir}
\end{quote}
che copia i tre file nella directory \texttt{\~{}} \texttt{/backup-dir}

\item Attenzione! Il comando

\begin{quote}
\texttt{cp lettera.doc {*}.txt }
\end{quote}
\end{enumerate}
\begin{quote}
diventa 
\begin{quote}
\texttt{cp lettera.doc memo.txt }
\end{quote}
che copia il primo file nel secondo, \textbf{distruggendolo!} 

\begin{LyXParagraphIndent}{0.10\columnwidth}
NOTA: in DOS, il comando

\end{LyXParagraphIndent}

\begin{LyXParagraphIndent}{0.10\columnwidth}
\begin{quote}
\texttt{\textcolor{red}{copy lettera.doc {*}.txt }}
\end{quote}\end{LyXParagraphIndent}

\begin{LyXParagraphIndent}{0.10\columnwidth}
significa invece

\end{LyXParagraphIndent}

\begin{LyXParagraphIndent}{0.10\columnwidth}
\begin{quote}
\texttt{\textcolor{red}{copy lettera.doc lettera.txt }}
\end{quote}\end{LyXParagraphIndent}

\end{quote}

\subsubsection{altre sostituzioni}

Oltre a quella sui nomi di file, la shell esegue una serie di sostituzioni sulla
riga di comando. Ogni sostituzione è distinta da un carattere speciale. 

\vspace{0.3cm}
{\centering \begin{tabular}{|c|c|c|}
\hline 
\emph{caratteri}&
\emph{sostituzione eseguita}&
\emph{esempio di comando}\\
\hline 
\hline 
\texttt{{*} ? {[}{]}}&
nomi di file &
\texttt{mv capitolo{*}.txt ../libro}\\
\hline 
\texttt{\~{}} &
directory di partenza (home directory) degli utenti&
\texttt{ls}\texttt{ \~{}tizio/tmp}\\
\hline 
\texttt{\$}&
variabili&
\texttt{echo Terminale definito come \$TERM}\\
\hline 
\texttt{!}&
cronologia (ultimi comandi dati)&
\texttt{!!}\\
\hline 
\texttt{``} &
risultato del comando&
\texttt{echo \char`\"{}Ci sono `who | wc -l` utenti collegati\char`\"{}}\\
\hline 
\end{tabular}\par}
\vspace{0.3cm}


\subsubsection{proteggere da sostituzione}

Quando si vuole usare un carattere speciale senza operare sostituzioni, lo si
può proteggere:

\begin{description}
\item [\texttt{\textbackslash{}}]protegge carattere successivo 
\item [\texttt{''}]protegge tutto il testo contenuto tra \texttt{' e '}
\item [\texttt{\char`\"{}\char`\"{}}]protegge una frase, tranne \texttt{\$ `} e \texttt{\textbackslash{}}
(che vengono interpretati)
\item [Es:]~
\end{description}
\begin{quote}
\texttt{\$ cd / }~\\
\texttt{\$ echo come va?}~\\
\texttt{come var}~\\
\texttt{\$ echo come va\textbackslash{}?}~\\
\texttt{come va?}~\\
\texttt{\$ echo 'questo carattere si chiama tilde: \~{}' }~\\
\texttt{questo carattere si chiama tilde: \~{} }~\\
\texttt{\$ echo questo carattere si chiama tilde: \~{} }~\\
\texttt{questo carattere si chiama tilde: /home/infochim}
\end{quote}

\subsubsection{esempi}

\begin{enumerate}
\item esaminare l'output di un comando una schermata alla volta

\vspace{0.3cm}
{\raggedright \begin{tabular}{ll}
\texttt{last}&
\emph{fa vedere tutte le ultime sessioni su questo computer}\\
\texttt{last > a.0}&
\emph{scrive il risultato su} \texttt{a.0}\\
\texttt{less a.0~~~~~~~~~~~~~~~}&
\emph{legge il risultato una schermata alla volta}\\
\texttt{last | less}&
\emph{combina i due comandi in uno solo}\\
\end{tabular}\par}
\vspace{0.3cm}

\item selezionare nomi in un elenco telefonico

\vspace{0.3cm}
{\raggedright \begin{tabular}{ll}
\texttt{grep Acciai telefonico.txt}&
\emph{seleziona righe che contengono} \texttt{Acciai}\\
\texttt{grep 'Acciai ' telefonico.txt} &
\emph{elimina} \texttt{Acciaioli}\\
\texttt{grep 'Acciai ' telefonico.txt > a.0~~~~~~~~~~~~~~~}&
\emph{mette il risultato su} \texttt{a.0}\\
\texttt{sort -k2 a.0}&
\emph{ordina le righe di} \texttt{a.0} \emph{secondo il nome (seconda parola)}\\
\end{tabular}\par}
\vspace{0.3cm}

Lo stesso risultato si ottiene con l'unico comando

\begin{quote}
\texttt{grep 'Acciai ' telefonico.txt} | {\selectlanguage{american}}\texttt{sort
-k2}
\end{quote}
\item contare gli atomi di idrogeno in un file PDB compresso

\vspace{0.3cm}
{\raggedright \begin{tabular}{ll}
\texttt{uncompress -c a.pdb.Z~~~~~~~~~~~~~~~}&
\emph{decomprime il file su standard output}\\
\texttt{uncompress -c a.pdb.Z > a.pdb~~~~~~~}&
\emph{decomprime il file su} \texttt{a.pdb}\\
\texttt{grep ' H ' a.pdb > idrogeni~~~~~~~~~}&
\emph{seleziona le righe che contengono atomi di H, e le mette in un nuovo file}\\
\texttt{wc -l idrogeni~~~~~~~~~~~~~~~~~~~~~~}&
\emph{conta le righe di questo nuovo file}\\
\end{tabular}\par}
\vspace{0.3cm}

Lo stesso risultato si ottiene con l'unico comando

\begin{quote}
\texttt{uncompress -c a.pdb.Z | grep ' H ' | wc -l}
\end{quote}
\item Statistiche sugli utenti del sistema

\vspace{0.3cm}
{\raggedright \begin{tabular}{ll}
\texttt{ypcat passwd > a.pw}&
\emph{visualizza tutti gli utenti definiti sul sistema}\\
\texttt{wc -l a.pw}&
\emph{conta le righe di} \texttt{a.pw}\\
\texttt{echo ci sono `ypcat passwd | wc -l` utenti~~~~~~~~~}&
\emph{scrive quanti sono gli utenti definiti} \\
\texttt{grep :2000: a.pw}&
\emph{seleziona solo gli utenti di chimica (gruppo 2000)}\\
\texttt{sort -t: -k3 a.pw}&
\emph{ordina gli utenti secondo il numero utente (terzo campo)}\\
\end{tabular}\par}
\vspace{0.3cm}

\item Statistiche sugli utenti del sistema

\vspace{0.3cm}
{\raggedright \begin{tabular}{ll}
\texttt{find}\texttt{ \~{}} \texttt{-mtime +30}&
\emph{visualizza tutti i miei file non modificati negli ultimi 30 giorni}\\
\texttt{mv `find}\texttt{ \~{}} \texttt{-mtime +30`}\texttt{ \~{}}\texttt{/oldfiles/~~~~~~~~~}&
\emph{li sposta nella directory} \texttt{oldfiles}\\
\end{tabular}\par}
\vspace{0.3cm}

\end{enumerate}

\newpage
\subsubsection{schema riassuntivo delle proprietà della shell}


\paragraph{input e output}

{\centering \begin{tabular}{|l|l|}
\hline 
\texttt{\emph{comando}}\texttt{~>~}\texttt{\emph{file}}&
dirigi output di \texttt{\emph{comando}} su \texttt{\emph{file}}\\
\hline 
\texttt{\emph{comando~<}}\texttt{~}\texttt{\emph{file}}&
prendi input di \texttt{\emph{comando}} da \texttt{\emph{file}}\\
\hline 
\texttt{\emph{comando1~}}\texttt{|~}\texttt{\emph{comando2}} &
l'output di \texttt{\emph{comando1}} diventa input di \texttt{\emph{comando2}}
(\emph{pipeline})\\
\hline 
\texttt{\emph{comando}}\texttt{~>\textcompwordmark{}>~}\texttt{\emph{file}}&
aggiungi output di \texttt{\emph{comando}} in coda a \texttt{\emph{file}}\\
\hline 
\end{tabular}\par}


\paragraph{processi}

{\centering \begin{tabular}{|l|l|}
\hline 
\texttt{\emph{comando1}} \texttt{;} \texttt{\emph{comando2}}&
 esegui \texttt{\emph{comando1}} , aspetta che sia terminato, poi esegui \texttt{\emph{comando2}}
\\
\hline 
\texttt{\emph{comando1}} \texttt{\&} \texttt{\emph{comando2}}&
 esegui \texttt{\emph{comando1}} , e senza aspettare che sia terminato esegui
\texttt{\emph{comando2}} \\
\hline 
\texttt{\emph{comando}} \texttt{\&}&
 esegui \texttt{\emph{comando}} in \emph{background}\\
\hline 
\texttt{\emph{Ctrl-C}}&
arresta definitivamente il processo in corso e rende il \emph{prompt}\\
\hline 
\texttt{\emph{Ctrl-Z}}&
sospende il processo in corso\\
\hline 
\texttt{fg}&
 ripristina il processo sospeso, in \emph{foreground}\\
\hline 
\texttt{bg}&
 ripristina il processo sospeso, in \emph{background}\\
\hline 
\texttt{jobs}&
 visualizza lista dei job\\
\hline 
\texttt{ps}&
 visualizza lista dei processi\\
\hline 
\texttt{kill \%}\texttt{\emph{j}}&
 arresta definitivamente il job \texttt{\emph{j}}\\
\hline 
\texttt{kill} \texttt{\emph{p}}&
 arresta definitivamente il processo \texttt{\emph{p}}\\
\hline 
\end{tabular}\par}


\paragraph{sostituzioni}

\vspace{0.3cm}
{\centering \begin{tabular}{|l|l|}
\hline 
\emph{espressione}&
\emph{sostituzione eseguita}\\
\hline 
\hline 
\texttt{{*}}&
nomi file: zero o più caratteri (tranne un \texttt{.} iniziale) \\
\hline 
 \texttt{?}&
nomi file: un solo carattere (tranne un \texttt{.} iniziale)\\
\hline 
\texttt{{[}abc{]}}&
nomi file: un solo carattere tra quelli citati tra parentesi (idem)\\
\hline 
\texttt{\~{}} &
directory di partenza (\emph{home directory}) di questo utente\\
\hline 
\texttt{\~{}}\texttt{\emph{xxx}} &
home directory dell'utente \texttt{\emph{xxx}}\\
\hline 
\texttt{\$}\texttt{\emph{var}}&
valore della variabile \texttt{\emph{var}}\\
\hline 
\texttt{!!}&
ultimo comando dato\\
\hline 
\texttt{`}\texttt{\emph{comando}}\texttt{`} &
risultato del comando \texttt{\emph{comando}}\\
\hline 
\texttt{\textbackslash{}} &
protegge da sostituzione il carattere successivo \\
\hline 
\texttt{''}&
 protegge tutto il testo contenuto tra \texttt{' e '}\\
\hline 
\texttt{\char`\"{}\char`\"{}} &
protegge il testo tra \char`\"{}\char`\"{}, tranne \texttt{\$ `} e \texttt{\textbackslash{}}\\
\hline 
\end{tabular}\par}
\vspace{0.3cm}


\newpage
\subsection{lista di comandi utili}


\paragraph{guide}

\begin{lyxcode}
man~~~~~-~format~and~display~the~on-line~manual~pages

apropos~-~search~the~whatis~database~for~strings

whatis~~-~search~the~whatis~database~for~complete~words
\end{lyxcode}

\paragraph{file, directory, dischi}

\begin{lyxcode}
ls~~~~~-~list~directory~contents

rm~~~~~-~remove~files~or~directories

mv~~~~~-~move~(rename)~files

cp~~~~~-~copy~files~and~directories

cd~~~~~-~Change~working~directory

pwd~~~~-~print~name~of~current/working~directory

mkdir~~-~make~directories

rmdir~~-~remove~empty~directories

chmod~~-~change~file~access~permissions

chown~~-~change~file~owner~and~group

find~~~-~search~for~files~in~a~directory~hierarchy

df~~~~~-~report~filesystem~disk~space~usage

du~~~~~-~estimate~file~space~usage
\end{lyxcode}

\paragraph{manipolazione di file}

\begin{lyxcode}
cat~~~~~-~concatenate~files~and~print~on~the~standard~output

more~~~~-~file~perusal~filter~for~crt~viewing

less~~~~-~opposite~of~more

sort~~~~-~sort~lines~of~text~files

head~~~~-~output~the~first~part~of~files

tail~~~~-~output~the~last~part~of~files~

grep~~~~-~print~lines~matching~a~pattern

wc~~~~~~-~print~the~number~of~bytes,~words,~and~lines~in~files

diff~~~~-~find~differences~between~two~files


\end{lyxcode}

\paragraph{manipolazione avanzata di file}

\begin{lyxcode}
sed~~~~~~~~~~~~~-~a~Stream~EDitor

gawk~{[}awk{]}~~~~~~-~pattern~scanning~and~processing~language
\end{lyxcode}

\paragraph{stampa e simile}

\begin{lyxcode}
lpr~~~~~-~off~line~print

lpq~~~~~-~spool~queue~examination~program

echo~~~~-~display~a~line~of~text
\end{lyxcode}

\paragraph{archiviazione e compressione}

\begin{lyxcode}
tar~~~~~-~The~GNU~version~of~the~tar~archiving~utility

compress~{[}uncompress{]}~-~compress~and~expand~data

gzip~~~~-~compress~or~expand~files


\end{lyxcode}

\paragraph{utenti, processi}

\begin{lyxcode}
passwd~~~-~update~a~user's~authentication~tokens(s)

yppasswd~-~change~your~password~in~the~NIS~database

finger~~~-~user~information~lookup~program

who~~~~~~-~show~who~is~logged~on

w~~~~~~~~-~Show~who~is~logged~on~and~what~they~are~doing

ps~~~~~~~-~report~process~status

kill~~~~~-~terminate~a~process


\end{lyxcode}

\subsection{vi }

\emph{(ottimo manuale: http://www.geek-girl.com/Unixhelp/vi/index.html~ {[}UHU{]})}


\paragraph{concetti base}

\begin{itemize}
\item modalità di operazione

\begin{itemize}
\item modalità comando
\item modalità inserimento
\end{itemize}
\item il registro (buffer)
\end{itemize}

\paragraph{avviamento e apertura di file}

\begin{itemize}
\item un file esistente
\item un file nuovo
\item senza argomenti
\end{itemize}

\paragraph{salvare e uscire}

\begin{lyxlist}{uscirexsenzaxsalvarex}
\item [\texttt{:w~{[}nomefile{]}}]salvare 
\item [\texttt{:q}]uscire 
\item [\texttt{:wq}]salvare e uscire 
\item [\texttt{:q!}]uscire senza salvare 
\end{lyxlist}

\paragraph{inserimento di testo}

\begin{lyxlist}{00.00.0000}
\item [\texttt{a}]inserire testo dopo il cursore
\item [\texttt{i}]inserire testo prima del cursore
\item [\texttt{o}]aggiungere una riga sotto
\item [\texttt{O}]aggiungere una riga sopra
\end{lyxlist}

\paragraph{muoversi}

\begin{lyxlist}{00.00.0000}
\item [\texttt{l}]cursore a destra
\item [\texttt{h}]cursore a sinistra
\item [\texttt{k}]cursore su
\item [\texttt{j}]cursore giù
\end{lyxlist}

\paragraph{cancellare}

\begin{lyxlist}{00.00.0000}
\item [\texttt{x}]carattere
\item [\texttt{dh}]carattere precedente
\item [\texttt{dd}]intera riga
\item [\texttt{d\$}]fino a fine riga
\item [\texttt{p}]annulla ultima cancellazione
\end{lyxlist}

\paragraph{cercare e sostituire}

\begin{lyxlist}{mmmmmmmmmmmmmmmm}
\item [\texttt{/}]cercare una serie di caratteri
\item [\texttt{?}]cercare una serie di caratteri, all'indietro
\item [\texttt{n}]cercare di nuovo in avanti
\item [\texttt{N}]cercare di nuovo indietro
\item [\texttt{:s/abc/xyz}]sostituire \texttt{abc} con \texttt{xyz} su una riga
\item [\texttt{:g/abc/s//xyz/gc}]sostituire \texttt{abc} con \texttt{xyz} in tutto
il documento, in modalità interattiva
\end{lyxlist}

\newpage
\section{UNIX: Approfondimenti}


\subsection{Regular Expression (espressioni regolari o formali)}

\begin{itemize}
\item Sono espressioni che descrivono sequenze di caratteri. Vengono usate in funzioni
e comandi (come \texttt{grep} o \texttt{awk}) che effettuano una ricerca di
sequenze di caratteri all'interno di righe o stringhe.
\item Si dice che c'è corrispondenza (\emph{match}) tra una RE e una sequenza di caratteri
contenuta in una stringa (e v.v.)
\item La forma più semplice di una RE è una pura sequenza di caratteri, che corrisponde
soltanto alla sequenza stessa:
\end{itemize}
Es: La RE \texttt{/ranc/} corrisponde alla sequenza \char`\"{}\texttt{ranc}\char`\"{}
contenuta sia nella stringa \char`\"{}\texttt{F}\texttt{\textbf{ranc}}\texttt{esco}\char`\"{}
che nella stringa \char`\"{}\texttt{mela}\texttt{\textbf{ranc}}\texttt{ia}\char`\"{}

\begin{itemize}
\item Con caratteri speciali si possono costruire RE che corrispondono a più di una
sequenza di caratteri. Ad es., il punto (\texttt{.}) rappresenta un qualsiasi
carattere.
\end{itemize}
Es: \texttt{/or.o/} corrisponde sia a \char`\"{}\texttt{orto}\char`\"{} che
a \char`\"{}\texttt{orco}\char`\"{}, che a ...

Una RE è composta da:

~

\begin{tabular}{|l|l|}
\hline 
 \emph{elemento:}&
\emph{corrisponde a:}\\
\hline 
\hline 
 \texttt{c}&
il carattere (non-speciale) \texttt{c}\\
\hline 
 \texttt{\textbackslash{}c}&
il carattere speciale \texttt{c}, preso letteralmente. Caratteri speciali: \texttt{.{*}\textbackslash{}{[}{]}\textasciicircum{}\$-\"{}'}\\
\hline 
 \texttt{.}&
qualsiasi carattere\\
\hline 
 \texttt{{[}abc...{]}}&
uno qualsiasi dei caratteri \texttt{abc}...\\
\hline 
 \texttt{{[}v-z{]}}&
= \texttt{{[}vwxyz{]}}\\
\hline 
 \texttt{{[}\textasciicircum{}abc...{]}}&
qualsiasi carattere eccetto \texttt{abc}...\\
\hline 
 \texttt{{[}\textasciicircum{}v-z{]}}&
= \texttt{{[}\textasciicircum{}vwxyz{]}}\\
\hline 
 \texttt{\textasciicircum{}}&
inizio stringa\\
\hline 
 \texttt{\$}&
fine stringa\\
\hline 
\end{tabular}

~

che si possono combinare nel modo seguente:

~

\begin{tabular}{|l|l|}
\hline 
 \texttt{\emph{r1r2}}&
 l'espressione \texttt{\emph{r1}} seguita dall'espressione \texttt{\emph{r2}}
\\
\hline 
\hline 
 \texttt{\emph{r}}\texttt{{*}}&
 l'espressione \texttt{\emph{r}} ripetuta zero o più volte \\
\hline 
 \texttt{\emph{r}}\texttt{+}&
 l'espressione \texttt{\emph{r}} ripetuta una o più volte \\
\hline 
\end{tabular}

~

Esempi: 

{\raggedright \begin{longtable}{|p{35mm}|p{150pt}|p{35mm}|}
\hline 
\texttt{\emph{RE}}\emph{}&
\parbox[t]{150pt}{\smallskip{} \emph{è contenuta~in}\emph{ \\}\emph{(in}\texttt{\textbf{\emph{\underbar{~neretto
sottolineato}}}}\emph{ \\}\emph{la corrispondenza) } \\
\smallskip{}}&
 \emph{non è contenuta in} \\
\hline 
\hline 
 \texttt{/ranc/}&
 \texttt{\"{}F}\texttt{\textbf{\underbar{ranc}}}\texttt{esco\"{}, \"{}mela}\texttt{\textbf{\underbar{ranc}}}\texttt{ia\"{}}&
 \texttt{~}\\
\hline 
 \texttt{/or.o/}&
 \texttt{\"{}}\texttt{\textbf{\underbar{orco}}}\texttt{\"{}, \"{}}\texttt{\textbf{\underbar{orto}}}\texttt{\"{}}&
 \texttt{\"{}oro\"{}}\\
\hline 
 \texttt{/si~do/}&
 \texttt{\"{}famo}\texttt{\textbf{\underbar{si~do}}}\texttt{ttori\"{}}&
 \texttt{\"{}famosi~~dottori\"{}}\\
\hline 
 \texttt{/{[}Ff{]}ranc/}&
 \texttt{\"{}}\texttt{\textbf{\underbar{Franc}}}\texttt{esco\"{}, \"{}}\texttt{\textbf{\underbar{franc}}}\texttt{esi\"{},
\"{}}\texttt{\textbf{\underbar{Franc}}}\texttt{ia\"{}}&
 \texttt{\"{}melarancia\"{}}\\
\hline 
 \texttt{/Franc.{*}a/ }&
 \texttt{\"{}}\texttt{\textbf{\underbar{Francesca}}}\texttt{\"{}, \"{}}\texttt{\textbf{\underbar{Francia}}}\texttt{\"{}}&
 \texttt{\"{}Francesco\"{}, \"{}francesca\"{}}\\
\hline 
 \texttt{/{[}Ff{]}rancesc{[}oa{]}/}&
 \texttt{\"{}}\texttt{\textbf{\underbar{Francesco}}}\texttt{\"{}, \"{}}\texttt{\textbf{\underbar{Francesca}}}\texttt{\"{},
\"{}}\texttt{\textbf{\underbar{francesco}}}\texttt{\"{}, \"{}}\texttt{\textbf{\underbar{francesca}}}\texttt{\"{},
\"{}}\texttt{\textbf{\underbar{Francesca}}}\texttt{to\"{}, \"{}Pier}\texttt{\textbf{\underbar{francesco}}}\texttt{\"{}}&
 \texttt{\"{}Francia\"{}}\\
\hline 
 \texttt{/tel\textbackslash{}.com/}&
 \texttt{\"{}www.alca}\texttt{\textbf{\underbar{tel.com}}}\texttt{\"{}}&
 \texttt{\"{}telecom\"{}}\\
\hline 
 \texttt{/\textasciicircum{}car.{*}o/}&
 \texttt{\"{}}\texttt{\textbf{\underbar{caro}}}\texttt{ta\"{}, \"{}}\texttt{\textbf{\underbar{carico}}}\texttt{\"{},
\"{}}\texttt{\textbf{\underbar{cart}}}\texttt{\textbf{o}}\texttt{ne\"{}}&
 \texttt{\"{}cara\"{}, \"{}Icaro\"{}}\\
\hline 
 \texttt{/car.{*}o\$/}&
 \texttt{\"{}I}\texttt{\textbf{\underbar{caro}}}\texttt{\"{}}&
 \texttt{\"{}carota\"{}}\\
\hline 
 \texttt{/bana{[}\textasciicircum{}n{]}e/}&
 \texttt{\"{}}\texttt{\textbf{\underbar{banale}}}\texttt{\"{}}&
 \texttt{\"{}banane\"{}}\\
\hline 
 \texttt{/ta.{*}a/}&
 \texttt{\"{}}\texttt{\textbf{\underbar{tanto va la gatta al la}}}\texttt{rdo\"{}}&
 \texttt{~}\\
\hline 
\end{longtable}\par}

~

In generale, una RE corrisponde alla stringa più lunga possibile.

Es:~ 

nella stringa \char`\"{}\texttt{tanto va la gatta al lardo}\char`\"{}, la RE
\texttt{/ta.{*}a/} corrisponde alla sottostringa \char`\"{}\texttt{tanto va
la gatta al la}\char`\"{}.

~


\subsection{awk}


\subsubsection{caratteristiche generali}

\begin{itemize}
\item È un comando che serve per elaborare file (di testo o numerici). 
\end{itemize}
Es: 

\begin{lyxcode}
awk~'\{print~\$1\}'~/etc/hosts
\end{lyxcode}
\begin{itemize}
\item Di fatto, è un linguaggio di programmazione \emph{interpretato}, con sua sintassi
e comandi. Si possono scrivere programmi in \emph{awk}.
\item C'è uno standard POSIX di linguaggio \emph{awk}. 
\item Su Linux RedHat trovate la versione GNU di \emph{awk} che si chiama anche \emph{gawk}
\end{itemize}

\subsubsection{manuali}

\begin{itemize}
\item \emph{http://www.gnu.org/manual/gawk/index.html}
\item \texttt{man awk}
\end{itemize}

\subsubsection{sintassi del comando awk}

Da \texttt{man awk}:

\begin{lyxcode}
SINTASSI

~~~~~~awk~{[}~opzioni~{]}~testo-del-programma~file~...

~~~~~~awk~{[}~opzioni~{]}~-f~file-di-programma~file~...
\end{lyxcode}
Cioè: 

\begin{itemize}
\item si possono dare istruzioni

\begin{itemize}
\item O sulla riga di comando (poche istruzioni, cfr. esempio precedente)
\item O in un programma già scritto, con l'opzione -f
\end{itemize}
\item awk è sempre dipendente da un file. (C'è comunque un \char`\"{}trucco\char`\"{}
per eseguire un programma senza file di input)
\end{itemize}
~


\subsubsection{istruzioni di awk}

\begin{itemize}
\item processa una riga (record) dell'input alla volta
\item su ciascuna riga esegue tutte le istruzioni, nell'ordine
\end{itemize}
Le istruzioni sono sempre del tipo

\begin{lyxcode}
pattern~\{action\}
\end{lyxcode}
che significa: se la riga contiene una stringa corrispondente a \texttt{pattern},
viene eseguita l'istruzione \texttt{action}.

Esempio:

\begin{lyxcode}
awk~'/polosci/~\{print~\$1,\$2\}'~/etc/hosts
\end{lyxcode}
Se \texttt{pattern} è assente, l'azione \texttt{action} viene sempre eseguita;
se l'\texttt{action} è assente, si stampa l'intera riga


\subsubsection{Campi}

Ogni volta che awk legge un record lo spezza in campi, usando il valore della
variabile FS (espressione regolare) come separatore di campo (default=sequenza
di spazi o un tabulatore o un accapo). Se FS è un singolo carattere, i campi
sono separati da quel carattere.

Es: il file \texttt{\emph{/etc/passwd}} ha il formato \texttt{user:password:userid:groupid:name:home:shell}

\begin{lyxcode}
xavier:x:1224:1000:Francesco:/home/xavier:/bin/bash
\end{lyxcode}
Ogni campo nel record in ingresso può essere individuato dalla sua posizione:
\texttt{\$1}, \texttt{\$2}, e così via. \texttt{\$0} è l'intero record.


\subsubsection{Variabili}

Si possono definire ed utilizzare delle variabili:

\begin{lyxcode}
r=25.

b=\char`\"{}ciao\char`\"{}

crf=r{*}2{*}3.14
\end{lyxcode}
il riferimento alle variabili è fatto in modo diretto, senza il carattere \char`\"{}\texttt{\$}\char`\"{}
(differenza da shell!)

I loro valori sono numeri in virgola mobile, o stringhe, o entrambe le cose,
a seconda di come sono usati.

AWK dispone di vettori monodimensionali (i vettori multidimensionali possono
essere simulati):

\begin{lyxcode}
x{[}i{]}=15
\end{lyxcode}
Al lancio del programma sono impostate parecchie variabili predefinite (es:
FS)


\subsubsection{Sequenze (\emph{pattern})}

\begin{itemize}
\item espressioni regolari riportate tra / e / 
\item oppure: espressioni relazionali\\
cioè quelle che usano (tra gli altri) gli operatori\\
\texttt{==~~~~~~!=~~ <~~ >~~~~~~ <=~~~~~ >=}
\item combinazioni di pattern, ad esempio con operatori logici \&\& ~~~~|| 
\item BEGIN e END
\end{itemize}

\subsubsection{azioni}

Le istruzioni possono essere assegnamenti o istruzioni condizionali o iterative
o di I/O come si trovano nella maggior parte dei linguaggi.

Gli operatori, le~ strutture di controllo e le istruzioni di input/output ricalcano
le corrispondenti del linguaggio C


\paragraph{Operatori}

\texttt{+~-~{*}~/~\textasciicircum{}}~~~~~~ etc.


\paragraph{Istruzioni di controllo}

\begin{lyxcode}
if~(\emph{condizione})~\emph{istruzione}~{[}~else~\emph{istruzione}~{]}

exit~
\end{lyxcode}

\paragraph{Istruzioni di I/O}

\begin{lyxcode}
print~{[}\emph{expr-list}{]}

next
\end{lyxcode}

\paragraph{Funzioni predefinite}

\begin{itemize}
\item numeriche: \texttt{cos()}, \texttt{exp()}, ...
\item di stringa; es \texttt{length()}
\end{itemize}

\subsubsection{un semplice esempio}

Nel file \texttt{\~{}}\texttt{\emph{infochim/wrk/esercitaz}} sono riportati
i punteggi ottenuti nelle prime due esercitazioni dai vari studenti del corso.
Il file contiene nell'ordine: nome account, turno, punteggio eserc.1, punteggio
eserc. 2:

\begin{lyxcode}
acciai~~~~~~~D~2~5

allegra~~~~~~A~2~3

allegri~~~~~~A~0~0

arturoni~~~~~A~2~5

...
\end{lyxcode}
La media dei punteggi della prima esercitazione si ottiene con il seguente programma
awk:

\begin{lyxcode}
~~~~~~~~~~~~~~~~\{s=s+\$3;n=n+1\}

END~~~~~~~~~~~~~\{print~\char`\"{}media=~\char`\"{},s/n\}
\end{lyxcode}
Possiamo scrivere questo programma nel file \texttt{\emph{media.awk}} e eseguire
il comando

\begin{lyxcode}
awk~-f~media.awk~esercitaz
\end{lyxcode}
Sull'output viene riportata la risposta:

\begin{lyxcode}
media=~1.54082
\end{lyxcode}
Se ora vogliamo il punteggio medio di chi appartiene al turno A, possiamo farlo
introducendo un pattern nella prima istruzione:

\begin{lyxcode}
/A/~~~~~~~~~~~~~\{s=s+\$3;n=n+1\}
\end{lyxcode}
Questo sistema funziona solo se siamo sicuri che l'account è sempre in minuscolo,
e che quindi la stringa \char`\"{}\texttt{A}\char`\"{} può essere presente solo
nel campo del turno.

Un sistema più corretto e sicuro è richiedere che la \texttt{A} si trovi nel
secondo campo. In questo caso il pattern deve essere non un'espressione regolare,
ma un'espressione relazionale:

\begin{lyxcode}
\$2==\char`\"{}A\char`\"{}~~~~~~~~~\{s=s+\$3;n=n+1\}
\end{lyxcode}
Se invece vogliamo stampare in fondo a ogni riga la somma dei due punteggi:

\begin{lyxcode}
~~~~~~~~~~~~~~~~\{print~\$0,~\$3+\$4\}
\end{lyxcode}
Questa istruzione invece stampa solo le righe relative a studenti che hanno
preso almeno 4 nella seconda esercitazione:

\begin{lyxcode}
\$4~>~3
\end{lyxcode}

\section{APPLICAZIONI SU UNIX}


\subsection{gnuplot}

\begin{itemize}
\item È un programma che serve per diagrammare

\begin{itemize}
\item file di dati
\item oppure funzioni
\end{itemize}
\item Si lancia con '\texttt{gnuplot}'
\item Il comando principale è '\texttt{plot}'
\end{itemize}

\paragraph{per diagrammare un file di dati esistente:}

\vspace{0.3cm}
{\raggedright \begin{tabular}{p{180pt}l}
\texttt{plot 'a.0'}&
usa la prima colonna come x, la seconda come y\\
\texttt{plot 'a.0' using 1:3}&
~~~~\char`\"{}~~\char`\"{}~~\char`\"{}~ ~ \char`\"{}~~~ , la terza
come y\\
\texttt{plot {[}1:10{]} 'a.0'}&
nell'intervallo {[}x=1, x=10{]}\\
\texttt{plot {[}1:10{]}{[}-100:100{]} 'a.0'}&
nell'intervallo {[}x=1, x=10{]} e {[}y=-100, y=100{]} \\
\texttt{plot 'a.0' with lines}&
formato del diagramma\\
\end{tabular}\par}
\vspace{0.3cm}


\paragraph{per diagrammare una funzione:}

\vspace{0.3cm}
{\raggedright \begin{tabular}{p{180pt}c}
\texttt{plot sin(x)}&
100 punti nell'intervallo {[}x=-10,x=10{]}\\
\end{tabular}\par}
\vspace{0.3cm}

\begin{lyxcode}

\end{lyxcode}
\begin{itemize}
\item si possono definire costanti e funzioni
\item Per uscire: \texttt{quit}
\item Per guida: \texttt{help}
\end{itemize}

\paragraph{Esempio: il pH di una soluzione per aggiunta di base forte. }

Per diagrammare i punti sperimentali contenuti nel file \texttt{\~{}}\texttt{\emph{infochim/wrk/titol}}
e la curva teorica \( pH(x)=14+\log _{10}(x) \) tra \( x=0.01 \) e \( x=1 \):

\begin{lyxcode}
cd~\~{}infochim/wrk

gnuplot

gnuplot>~plot~{[}0.01:1{]}~'titol',~14.+log(x)/log(10.)
\end{lyxcode}

\subsection{grafica molecolare: jmol (openscience)}


\subsection{esercizi}

calcolo proprietà di una molecola da geometria:

\begin{itemize}
\item dipolo
\item centro di massa, momento di inerzia
\end{itemize}

\section{Note}


\subsection{nota: la tastiera}

UNIX fa uso di alcuni caratteri che non sono presenti sulle tastiere italiane.
Sui calcolatori dell'aula didattica (aula 40) questi caratteri si ottengono
con le seguenti combinazioni:

\vspace{0.3cm}
{\centering \begin{tabular}{|c|c|}
\hline 
\textbf{\emph{Per scrivere:}}&
\textbf{\emph{digitare:}}\\
\hline 
\hline 
\texttt{\~{}}\texttt{}&
\texttt{AltGr í}\\
\hline 
\texttt{\{}&
\texttt{AltGr 7}\\
\hline 
\texttt{\}}&
\texttt{AltGr =}\\
\hline 
\texttt{`}&
\texttt{AltGr '}\\
\hline 
\end{tabular}\par}
\vspace{0.3cm}

~

\begin{thebibliography}{LinuxFlash}
\bibitem[LinuxFlash]{LinuxFlash}M. A. Ricar, Linux flash - Apogeo, 1999 -ISBN 88-7303-506-X
\bibitem[UNIX]{UNIX Kernighan}B.W. Kernighan, R. Pike, UNIX - Zanichelli, 1989 - ISBN 88-08-04376-2
\bibitem[LinuxRef]{LinuxRef Petersen}R. Petersen, Linux: the Complete Reference, Sec - Osborne McGraw-Hill, 1998
- ISBN 0-07-882461-3
\bibitem[AIL]{AppuntiInfoLibera}Appunti di Informatica Libera:.http://www.pluto.linux.it/ildp/AppuntiLinux/a2.html
\bibitem[BIU]{BriefIntroUnix}A Brief Introduction to Unix: http://staff.washington.edu/\texttt{\~{}}corey/unix-intro+man.html
\bibitem[UHU]{UnixHelp}Unix Help for Users: http://www.geek-girl.com/Unixhelp/
\bibitem[4LW]{4letterword}Unix is a Four-Letter Word:http://www.caspur.it/guidautenti/unix/4ltrwrd/\end{thebibliography}

\end{document}
