X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=filestd.tex;h=0070226a6f0363da8754d42d2084048e0f539a6b;hp=2e9b05af38d47538260c57eb57836ead8850735e;hb=f43b330570ece41d80aaca3c775eb4b7835aab28;hpb=8afc898ae5530e3ef1073505c894bb1b738ec916

diff --git a/filestd.tex b/filestd.tex
index 2e9b05a..0070226 100644
--- a/filestd.tex
+++ b/filestd.tex
@@ -1,4 +1,4 @@
- \chapter{I file: l'interfaccia standard ANSI C}
+\chapter{I file: l'interfaccia standard ANSI C}
 \label{cha:files_std_interface}
 
 Esamineremo in questo capitolo l'interfaccia standard ANSI C per i file,
@@ -228,7 +228,7 @@ prototipi sono:
     viene settata al valore ricevuto dalla funzione sottostante di cui è
     fallita l'esecuzione.
   
-    Gli errori pertanto possono essere quelli di \func{malloc} per tutte
+    Gli errori pertanto possono essere quelli di \code{malloc} per tutte
     e tre le funzioni, quelli \func{open} per \func{fopen}, quelli di
     \func{fcntl} per \func{fdopen} e quelli di \func{fopen},
     \func{fclose} e \func{fflush} per \func{freopen}.}
@@ -284,7 +284,7 @@ possono essere aperti con le funzioni delle librerie standard del C.
 In realtà lo standard ANSI C prevede un totale di 15 possibili valori
 diversi per \param{mode}, ma in \tabref{tab:file_fopen_mode} si sono
 riportati solo i sei valori effettivi, ad essi può essere aggiunto pure
-il carattere \func{b} (come ultimo carattere o nel mezzo agli altri per
+il carattere \texttt{b} (come ultimo carattere o nel mezzo agli altri per
 le stringhe di due caratteri) che in altri sistemi operativi serve a
 distinguere i file binari dai file di testo; in un sistema POSIX questa
 distinzione non esiste e il valore viene accettato solo per
@@ -304,13 +304,12 @@ valore \verb|STRING| 
 e \func{fopen} marca il file per l'uso dei caratteri estesi e abilita le
 opportune funzioni di conversione in lettura e scrittura.
 
-Inoltre nel caso si usi \func{fdopen} i valori specificati da
-\param{mode} devono essere compatibili con quelli con cui il file
-descriptor è stato aperto. Inoltre i modi \cmd{w} e \cmd{w+} non
-troncano il file. La posizione nello stream viene settata a quella
-corrente nel file descriptor, e le variabili di errore e di fine del
-file (vedi \secref{sec:file_io}) sono cancellate. Il file non viene
-duplicato e verrà chiuso alla chiusura dello stream.
+Nel caso si usi \func{fdopen} i valori specificati da \param{mode} devono
+essere compatibili con quelli con cui il file descriptor è stato aperto.
+Inoltre i modi \cmd{w} e \cmd{w+} non troncano il file. La posizione nello
+stream viene settata a quella corrente nel file descriptor, e le variabili di
+errore e di fine del file (vedi \secref{sec:file_io}) sono cancellate. Il file
+non viene duplicato e verrà chiuso alla chiusura dello stream.
 
 I nuovi file saranno creati secondo quanto visto in
 \secref{sec:file_ownership} ed avranno i permessi di accesso settati al
@@ -330,7 +329,7 @@ una scrittura una delle funzioni \func{fflush}, \func{fseek}, \func{fsetpos} o
 \func{rewind} prima di eseguire una rilettura; viceversa nel caso in cui si
 voglia fare una scrittura subito dopo aver eseguito una lettura occorre prima
 usare una delle funzioni \func{fseek}, \func{fsetpos} o \func{rewind}. Anche
-una operazione nominalmente nulla come \func{fseek(file, 0, SEEK\_CUR)} è
+una operazione nominalmente nulla come \code{fseek(file, 0, SEEK\_CUR)} è
 sufficiente a garantire la sincronizzazione.
 
 Una volta aperto lo stream, si può cambiare la modalità di bufferizzazione
@@ -355,9 +354,9 @@ dati presenti nei buffer in user space usati dalle \acr{glibc}; se si vuole
 essere sicuri che il kernel forzi la scrittura su disco occorrerà effettuare
 una \func{sync} (vedi \secref{sec:file_sync}).
 
-Linux supporta, come estensione implementata dalle \acr{glibc}, anche una
-altra funzione, \func{fcloseall}, che serve a chiudere tutti i file, il suo
-prototipo è:
+Linux supporta anche una altra funzione, \func{fcloseall}, come estensione GNU
+implementata dalle \acr{glibc}, accessibile avendo definito
+\macro{\_GNU\_SOURCE}, il suo prototipo è:
 \begin{prototype}{stdio.h}{int fcloseall(void)}
   Chiude tutti gli stream. 
   
@@ -396,7 +395,7 @@ notificato come tale dai valori di uscita delle varie funzioni. Nella
 maggior parte dei casi questo avviene con la restituzione del valore
 intero (di tipo \type{int}) \macro{EOF}\footnote{la costante deve essere
   negativa, le \acr{glibc} usano -1, altre implementazioni possono avere
-  valori diversi.}  definito anch'esso nell'header \func{stdlib.h}.
+  valori diversi.}  definito anch'esso nell'header \file{stdlib.h}.
 
 Dato che le funzioni dell'interfaccia degli stream sono funzioni di libreria
 che si appoggiano a delle system call, esse non settano direttamente la
@@ -489,10 +488,10 @@ si avr
 struct histogram {
     int nbins; 
     double max, min;
-    double * bin;
+    double *bin;
 } histo; 
 
-int WriteStruct(FILE * stream, struct histogram * histo, size_t nelem) 
+int WriteStruct(FILE *stream, struct histogram *histo, size_t nelem) 
 {
     if ( fwrite(vec, sizeof(*histo), 1, stream) !=1) {
         perror("Write error");
@@ -504,7 +503,7 @@ in cui si specifica la dimensione dell'intera struttura ed un solo
 elemento. 
 
 In realtà quello che conta nel trasferimento dei dati sono le dimensioni
-totali, che sono sempre pari al prodotto \func{size * nelem}; la sola
+totali, che sono sempre pari al prodotto \code{size * nelem}; la sola
 differenza è che le funzioni non ritornano il numero di byte scritti,
 ma il numero di elementi.
 
@@ -546,10 +545,9 @@ rileggere i dati tenendo conto delle eventuali differenze.
 Le \acr{glibc} definiscono altre due funzioni per l'I/O binario, che
 evitano il lock implicito dello stream, usato per dalla librerie per la
 gestione delle applicazioni multi-thread (si veda
-\secref{sec:file_stream_thread} per i dettagli).
-
+\secref{sec:file_stream_thread} per i dettagli):
 \begin{functions}
-  \headdecl{stdio.h} 
+  \headdecl{stdio.h}
   
   \funcdecl{size\_t fread\_unlocked(void *ptr, size\_t size, size\_t
     nmemb, FILE *stream)}
@@ -580,7 +578,7 @@ rispettivi prototipi sono:
   \funcdecl{int fgetc(FILE *stream)} Legge un byte da \param{stream} e lo
   restituisce come intero. È una sempre una funzione.
   
-  \funcdecl{int getchar(void)} Equivalente a \func{getc(stdin)}.
+  \funcdecl{int getchar(void)} Equivalente a \code{getc(stdin)}.
   
   \bodydesc{Tutte queste funzioni leggono un byte alla volta, che viene
     restituito come intero; in caso di errore o fine del file il valore
@@ -589,14 +587,14 @@ rispettivi prototipi sono:
 
 A parte \func{getchar}, che si usa in genere per leggere un carattere da
 tastiera, le altre due funzioni sono sostanzialmente equivalenti. La
-differenza è che \func{gets} è ottimizzata al massimo e normalmente
+differenza è che \func{getc} è ottimizzata al massimo e normalmente
 viene implementata con una macro, per cui occorre stare attenti a cosa
 le si passa come argomento, infatti \param{stream} può essere valutato
 più volte nell'esecuzione, e non viene passato in copia con il
 meccanismo visto in \secref{sec:proc_var_passing}; per questo motivo se
 si passa una espressione si possono avere effetti indesiderati.
 
-Invece \func{fgets} è assicurata essere sempre una funzione, per questo
+Invece \func{fgetc} è assicurata essere sempre una funzione, per questo
 motivo la sua esecuzione normalmente è più lenta per via dell'overhead
 della chiamata, ma è altresì possibile ricavarne l'indirizzo, che può
 essere passato come parametro ad un altra funzione (e non si hanno i
@@ -621,7 +619,7 @@ byte restituiscono un carattere in formato esteso (cio
   \funcdecl{wint\_t fgetwc(FILE *stream)} Legge un carattere esteso da
   \param{stream} È una sempre una funzione.
   
-  \funcdecl{wint\_t getwchar(void)} Equivalente a \func{getwc(stdin)}.
+  \funcdecl{wint\_t getwchar(void)} Equivalente a \code{getwc(stdin)}.
   
   \bodydesc{Tutte queste funzioni leggono un carattere alla volta, in
     caso di errore o fine del file il valore di ritorno è \macro{WEOF}.}
@@ -639,7 +637,7 @@ precedenti usate per leggere: \func{putc}, \func{fputc} e
   \funcdecl{int fputc(FILE *stream)} Scrive il carattere \param{c} su
   \param{stream}. È una sempre una funzione.
   
-  \funcdecl{int putchar(void)} Equivalente a \func{putc(stdin)}.
+  \funcdecl{int putchar(void)} Equivalente a \code{putc(stdin)}.
   
   \bodydesc{Le funzioni scrivono sempre un carattere alla volta, il cui
     valore viene restituito in caso di successo; in caso di errore o
@@ -654,7 +652,7 @@ sempre un intero; in caso di errore o fine del file il valore di ritorno
 
 Come nel caso dell'I/O binario le \acr{glibc} provvedono per ciascuna
 delle funzioni precedenti, come estensione GNU, una seconda funzione, il
-cui nome è ottenuto aggiungendo un \func{\_unlocked}, che esegue
+cui nome è ottenuto aggiungendo un \code{\_unlocked}, che esegue
 esattamente le stesse operazioni evitando però il lock implicito dello
 stream.
 
@@ -745,13 +743,13 @@ prototipi sono:
     di successo o \macro{NULL} in caso di errore.}
 \end{functions}
 
-Entrambe le funzioni effettuano la lettura (dal file specificato
-\func{fgets}, dallo standard input \func{gets}) di una linea di
-caratteri (terminata dal carattere \textit{newline}, \verb|\n|), ma
-\func{gets} sostituisce \verb|\n| con uno zero, mentre \func{fgets}
-aggiunge uno zero dopo il \textit{newline}, che resta dentro la
-stringa. Se la lettura incontra la fine del file (o c'è un errore) viene
-restituito un \macro{NULL}, ed il buffer \param{buf} non viene toccato.
+Entrambe le funzioni effettuano la lettura (dal file specificato \func{fgets},
+dallo standard input \func{gets}) di una linea di caratteri (terminata dal
+carattere \textit{newline}, \verb|\n|, quello mappato sul tasto di ritorno a
+capo della tastiera), ma \func{gets} sostituisce \verb|\n| con uno zero,
+mentre \func{fgets} aggiunge uno zero dopo il \textit{newline}, che resta
+dentro la stringa. Se la lettura incontra la fine del file (o c'è un errore)
+viene restituito un \macro{NULL}, ed il buffer \param{buf} non viene toccato.
 
 L'uso di \func{gets} è deprecato e deve essere assolutamente evitato; la
 funzione infatti non controlla il numero di byte letti, per cui nel caso
@@ -794,13 +792,13 @@ rispettivi prototipi sono:
     successo o \macro{EOF} in caso di errore.}
 \end{functions}
 
-Dato che in questo caso si scrivono i dati in uscita \func{puts} non ha
-i problemi di \func{gets} ed è in genere la forma più immediata per
-scrivere messaggi sullo standard output; la funzione prende una stringa
-terminata da uno zero ed aggiunge automaticamente un newline. La
-differenza con \func{fputs} (a parte la possibilità di specificare un
-file diverso da \var{stdout}) è che quest'ultima non aggiunge il
-newline, che deve essere previsto esplicitamente. 
+Dato che in questo caso si scrivono i dati in uscita \func{puts} non ha i
+problemi di \func{gets} ed è in genere la forma più immediata per scrivere
+messaggi sullo standard output; la funzione prende una stringa terminata da
+uno zero ed aggiunge automaticamente il ritorno a capo. La differenza con
+\func{fputs} (a parte la possibilità di specificare un file diverso da
+\var{stdout}) è che quest'ultima non aggiunge il newline, che deve essere
+previsto esplicitamente.
 
 Come per le funzioni di input/output a caratteri esistono le estensioni
 per leggere e scrivere caratteri estesi, i loro prototipi sono:
@@ -825,7 +823,7 @@ anzich
 Come nel caso dell'I/O binario e a caratteri nelle \acr{glibc} sono
 previste una serie di altre funzioni, estensione di tutte quelle
 illustrate finora (eccetto \func{gets} e \func{puts}), il cui nome si
-ottiene aggiungendo un \func{\_unlocked}, e che eseguono esattamente le
+ottiene aggiungendo un \code{\_unlocked}, e che eseguono esattamente le
 stesse operazioni delle loro equivalenti, evitando però il lock
 implicito dello stream (vedi \secref{sec:file_stream_thread}).
 
@@ -908,25 +906,24 @@ chiama \func{getdelim} ed il suo prototipo 
   carattere di newline come separatore di linea.
 \end{prototype}
 
-Il comportamento di \func{getdelim} è identico a quello di
-\func{getline} (che può essere implementata da questa passando
-\verb|'\n'| come valore di \param{delim}).
+Il comportamento di \func{getdelim} è identico a quello di \func{getline} (che
+può essere implementata da questa passando \verb|'\n'| come valore di
+\param{delim}).
 
 
-\subsection{Input/output formattato}
+\subsection{L'input/output formattato}
 \label{sec:file_formatted_io}
 
 L'ultima modalità di input/output è quella formattata, che è una delle
-caratteristiche più utilizzate delle librerie standard del C; in genere
-questa è la modalità in cui si esegue normalmente l'output su terminale
-poichè permette di stampare in maniera facile e veloce dati, tabelle e
-messaggi.
+caratteristiche più utilizzate delle librerie standard del C; in genere questa
+è la modalità in cui si esegue normalmente l'output su terminale poiché
+permette di stampare in maniera facile e veloce dati, tabelle e messaggi.
 
-L'output formattato viene eseguito con una delle 13 funzioni della
-famiglia \func{printf}; le tre più usate sono le seguenti:
+L'output formattato viene eseguito con una delle 13 funzioni della famiglia
+\func{printf}; le tre più usate sono le seguenti:
 \begin{functions}
   \headdecl{stdio.h} 
-  \funcdecl{int printf(const char *format, ...)} Stampa su \var{stdout}
+  \funcdecl{int printf(const char *format, ...)} Stampa su \file{stdout}
   gli argomenti, secondo il formato specificato da \param{format}.
   
   \funcdecl{int fprintf(FILE *stream, const char *format, ...)}  Stampa
@@ -943,7 +940,7 @@ famiglia \func{printf}; le tre pi
 o quello specificato) la terza permette di stampare su una stringa, in genere
 l'uso di \func{sprintf} è sconsigliato in quanto è possibile, se non si ha la
 sicurezza assoluta sulle dimensioni del risultato della stampa, eccedere le
-dimensioni di \param{str} con conseguente sovrascrittura di altre varibili e
+dimensioni di \param{str} con conseguente sovrascrittura di altre variabili e
 possibili buffer overflow; per questo motivo si consiglia l'uso
 dell'alternativa:
 \begin{prototype}{stdio.h}
@@ -1003,23 +1000,30 @@ degli specificatori di conversione (riportati in \ntab) che la conclude.
   \label{tab:file_format_spec}
 \end{table}
 
-
 Il formato di una direttiva di conversione prevede una serie di possibili
-elementi opzionali oltre al \cmd{\%} e allo specificatore di conversione; in
+elementi opzionali oltre al \cmd{\%} e allo specificatore di conversione. In
 generale essa è sempre del tipo:
 \begin{center}
 \begin{verbatim}
 % [n. parametro $] [flag] [[larghezza] [. precisione]] [tipo] conversione
 \end{verbatim}
 \end{center}
-in cui i valori opzionali sono indicati fra parentesi, e prevedono la
-presenza, in questo ordine, di: uno specificatore per il parametro da usare
-(terminato da un \cmd{\$}, uno o più flag (riassunti in
-\tabref{tab:file_format_flag}) che controllano il formato di stampa della
-conversione (riassunti in \tabref{tab:file_format_type}), uno specificatore di
-larghezza, eventualmente seguito (per i numeri in virgola mobile) da un
-specificatore di precisione, uno specificatore del tipo di dato (che ne indica
-la lunghezza).
+in cui tutti i valori tranne il \cmd{\%} e lo specificatore di conversione
+sono opzionali (e per questo sono indicati fra parentesi quadre); si possono
+usare più elementi opzionali, nel qual caso devono essere specificati in
+questo ordine:
+\begin{itemize*}
+\item uno specificatore del parametro da usare (terminato da un \cmd{\$}),
+\item uno o più flag (i cui valori possibili sono riassunti in
+  \tabref{tab:file_format_flag}) che controllano il formato di stampa della
+  conversione
+\item uno specificatore di larghezza (un numero decimale), eventualmente
+  seguito (per i numeri in virgola mobile) da un specificatore di precisione
+  (un altro numero decimale),
+\item uno specificatore del tipo di dato, che ne indica la dimensione (i cui
+  valori possibili sono riassunti in \tabref{tab:file_format_type}).
+\end{itemize*}
+
 
 \begin{table}[htb]
   \centering
@@ -1050,17 +1054,17 @@ di \func{printf} e nella documentazione delle \acr{glibc}.
     \textbf{Valore} & \textbf{Significato} \\
     \hline
     \hline
-    \cmd{hh} & una conversione intera corriponde a un \type{char} con o senza
+    \cmd{hh} & una conversione intera corrisponde a un \type{char} con o senza
                segno, o il puntatore per il numero dei parametri \cmd{n} è di 
                tipo \type{char}.\\
-    \cmd{h}  & una conversione intera corriponde a uno \type{short} con o 
+    \cmd{h}  & una conversione intera corrisponde a uno \type{short} con o 
                senza segno, o il puntatore per il numero dei parametri \cmd{n}
                è di tipo \type{short}.\\
-    \cmd{l}  & una conversione intera corriponde a un \type{long} con o 
+    \cmd{l}  & una conversione intera corrisponde a un \type{long} con o 
                senza segno, o il puntatore per il numero dei parametri \cmd{n}
                è di tipo \type{long}, o il carattere o la stringa seguenti
                sono in formato esteso.\\ 
-    \cmd{ll} & una conversione intera corriponde a un \type{long long} con o 
+    \cmd{ll} & una conversione intera corrisponde a un \type{long long} con o 
                senza segno, o il puntatore per il numero dei parametri \cmd{n}
                è di tipo \type{long long}.\\
     \cmd{L}  & una conversione in virgola mobile corrisponde a un
@@ -1078,8 +1082,8 @@ di \func{printf} e nella documentazione delle \acr{glibc}.
 \end{table}
 
 Una versione alternativa delle funzioni di output formattato, che permettono
-di usare il puntatore ad una lista di argomenti (vedi \secref{proc_variadic}),
-sono le seguenti:
+di usare il puntatore ad una lista di argomenti (vedi
+\secref{sec:proc_variadic}), sono le seguenti:
 \begin{functions}
   \headdecl{stdio.h} 
   
@@ -1113,11 +1117,99 @@ scritti sulla stringa di destinazione:
   Identica a \func{vsprintf}, ma non scrive su \param{str} più di
   \param{size} caratteri.
 \end{prototype}
+\noindent in modo da evitare possibili buffer overflow.
 
-Per evitare questi problemi con la stampa su stringhe di lunghezza
-insuffciente le \acr{glibc} supportano una estensione specifica GNU che alloca
-dinamicamente tutto lo spazio necessario; l'estensione si attiva al solito
-definendo \macro{\_GNU\_SOURCE}, 
+
+Per eliminare alla radice questi problemi, le \acr{glibc} supportano una
+estensione specifica GNU che alloca dinamicamente tutto lo spazio necessario;
+l'estensione si attiva al solito definendo \macro{\_GNU\_SOURCE}, le due
+funzioni sono:
+\begin{functions}
+  \headdecl{stdio.h} 
+    
+  \funcdecl{int asprintf(char **strptr, const char *format, ...)}  Stampa gli
+  argomenti specificati secondo il formato specificato da \param{format} su
+  una stringa allocata automaticamente all'indirizzo \param{*strptr}.
+  
+  \funcdecl{int vasprintf(char **strptr, const char *format, va\_list ap)}
+  Stampa gli argomenti della lista \param{ap} secondo il formato specificato
+  da \param{format} su una stringa allocata automaticamente all'indirizzo
+  \param{*strptr}.
+
+  \bodydesc{Le funzioni ritornano il numero di caratteri stampati.}
+\end{functions}
+Entrambe le funzioni prendono come parametro \param{strptr} che deve essere
+l'indirizzo di un puntatore ad una stringa di caratteri, in cui verrà
+restituito (si ricordi quanto detto in \secref{sec:proc_var_passing} a
+proposito dei \textit{value result argument}) l'indirizzo della stringa
+allogata automaticamente dalle funzioni. Occorre inoltre ricordarsi di
+invocare \func{free} per liberare detto puntatore quando la stringa non serve
+più, onde evitare memory leak.
+
+Infine una ulteriore estensione GNU definisce le due funzioni \func{dprintf} e
+\func{vdprintf}, che prendono un file descriptor al posto dello stream. Altre
+estensioni permettono di scrivere con caratteri estesi. Anche queste funzioni,
+il cui nome è generato dalle precedenti funzioni aggiungendo una \texttt{w}
+davanti a \texttt{print}, sono trattate in dettaglio nella documentazione delle
+\acr{glibc}.
+
+In corrispondenza alla famiglia di funzioni \func{printf} che si usano per
+l'output formattato, l'input formattato viene eseguito con le funzioni della
+famiglia \func{scanf}; fra queste le tre più importanti sono:
+\begin{functions}
+  \headdecl{stdio.h} \funcdecl{int scanf(const char *format, ...)} Esegue una
+  scansione di \file{stdin} cercando una corrispondenza di quanto letto con il
+  formato dei dati specificato da \param{format}, ed effettua le relative
+  conversione memorizzando il risultato nei parametri seguenti.
+  
+  \funcdecl{int fscanf(FILE *stream, const char *format, ...)}  Analoga alla
+  precedente, ma effettua la scansione su \param{stream}.
+  
+  \funcdecl{int sscanf(char *str, const char *format, ...)} Analoga alle
+  precedenti, ma effettua la scansione dalla stringa \param{str}.
+  
+  \bodydesc{Le funzioni ritornano il numero di elementi assegnati. Questi
+    possono essere in numero inferiore a quelli specificati, ed anche zero.
+    Quest'ultimo valore significa che non si è trovata corrispondenza. In caso
+    di errore o fine del file viene invece restituito \macro{EOF}.}
+\end{functions}
+\noindent e come per le analoghe funzioni di scrittura esistono le relative
+\func{vscanf}, \func{vfscanf} \func{vsscanf} che usano un puntatore ad una
+lista di argomenti.
+
+Tutte le funzioni della famiglia delle \func{scanf} vogliono come argomenti i
+puntatori alle variabili che dovranno contenere le conversioni; questo è un
+primo elemento di disagio in quanto è molto facile dimenticarsi di questa
+caratteristica.
+
+Le funzioni leggono i caratteri dallo stream (o dalla stringa) di input ed
+eseguono un confronto con quanto indicato in \param{format}, la sintassi di
+questo parametro è simile a quella usata per l'analogo di \func{printf}, ma ci
+sono varie differenze.  Le funzioni di input infatti sono più orientate verso
+la lettura di testo libero che verso un input formattato in campi fissi. Uno
+spazio in \param{format} corrisponde con un numero qualunque di caratteri di
+separazione (che possono essere spazi, tabulatori, virgole etc.), mentre
+caratteri diversi richiedono una corrispondenza esatta. Le direttive di
+conversione sono analoghe a quelle di \func{printf} e si trovano descritte in
+dettaglio nelle man page e nel manuale delle \acr{glibc}.
+
+Le funzioni eseguono la lettura dall'input, scartano i separatori (e gli
+eventuali caratteri diversi indicati dalla stringa di formato) effettuando le
+conversioni richieste; in caso la corrispondenza fallisca (o la funzione non
+sia in grado di effettuare una delle conversioni richieste) la scansione viene
+interrotta immediatamente e la funzione ritorna lasciando posizionato lo
+stream al primo carattere che non corrisponde.
+
+Data la notevole complessità di uso di queste funzioni, che richiedono molta
+cura nella definizione delle corrette stringhe di formato e sono facilmente
+soggette ad errori, e considerato anche il fatto che è estremamente macchinoso
+recuperare in caso di fallimento nelle corrispondenze, l'input formattato non
+è molto usato. In genere infatti quando si ha a che fare con un input
+relativamente semplice si preferisce usare l'input di linea ed effettuare
+scansione e conversione di quanto serve direttamente con una delle funzioni di
+conversione delle stringhe; se invece il formato è più complesso diventa più
+facile utilizzare uno strumento come il \cmd{flex} per generare un
+analizzatore lessicale o il \cmd{bison} per generare un parser.
 
 
 \subsection{Posizionamento su uno stream}
@@ -1129,14 +1221,14 @@ punto prestabilito; questo fintanto che l'operazione di riposizionamento 
 supportata dal file sottostante lo stream, quando cioè si ha a che fare con
 quello che viene detto un file ad \textsl{accesso casuale}.
 
-In GNU/Linux ed in generale in ogni sistema unix-like la posizione nel
-file è espressa da un intero positivo, rappresentato dal tipo
-\type{off\_t}, il problema è alcune delle funzioni usate per il
-riposizionamento sugli stream originano dalle prime versioni di unix in
-cui questo tipo non era ancora stato definito, e che in altri sistemi
-non è detto che la posizione su un file venga sempre rappresentata con
-un numero di caratteri (ad esempio in VMS può essere rappresentata come
-numero di record, e offset rispetto al record corrente).
+In GNU/Linux ed in generale in ogni sistema unix-like la posizione nel file è
+espressa da un intero positivo, rappresentato dal tipo \type{off\_t}, il
+problema è alcune delle funzioni usate per il riposizionamento sugli stream
+originano dalle prime versioni di Unix, in cui questo tipo non era ancora
+stato definito, e che in altri sistemi non è detto che la posizione su un file
+venga sempre rappresentata con il numero di caratteri dall'inizio (ad esempio
+in VMS può essere rappresentata come numero di record, e offset rispetto al
+record corrente).
 
 Tutto questo comporta la presenza di diverse funzioni che eseguono
 sostanzialmente le stesse operazioni, ma usano parametri di tipo
@@ -1153,32 +1245,59 @@ posizione in uno stream sono:
   all'inizio del file.
 \end{functions}
 
-L'uso di \func{fseek} è del tutto analogo a quello di \func{lseek} per i
-file descriptor, ed i parametri, a parte il tipo, hanno lo stesso
-significato; in particolare \param{whence} assume gli stessi valori già
-visti in \secref{sec:file_lseek}. La funzione restituisce 0 in caso di
-successo e -1 in caso di errore. 
+L'uso di \func{fseek} è del tutto analogo a quello di \func{lseek} per i file
+descriptor, ed i parametri, a parte il tipo, hanno lo stesso significato; in
+particolare \param{whence} assume gli stessi valori già visti in
+\secref{sec:file_lseek}.  La funzione restituisce 0 in caso di successo e -1
+in caso di errore.  La funzione \func{rewind} riporta semplicemente la
+posizione corrente all'inizio dello stream, ma non esattamente equivalente ad
+una \code{fseek(stream, 0L, SEEK\_SET)} in quanto vengono cancellati anche i
+flag di errore e fine del file.
 
-Per leggere la posizione corrente si usa invece la funzione \func{ftell}, il
+Per ottenere la posizione corrente si usa invece la funzione \func{ftell}, il
 cui prototipo è:
 \begin{prototype}{stdio.h}{long ftell(FILE *stream)} 
-  Legge la posizione attuale nello stream.
+  Legge la posizione attuale nello stream \param{stream}.
   
   \bodydesc{La funzione restituisce la posizione corrente, o -1 in caso
     di fallimento, che può esser dovuto sia al fatto che il file non
     supporta il riposizionamento che al fatto che la posizione non può
     essere espressa con un \type{long int}}
 \end{prototype}
-
+\noindent la funzione restituisce la posizione come numero di byte
+dall'inizio dello stream. 
+
+Queste funzioni esprimono tutte la posizione nel file come un \func{long int},
+dato che (ad esempio quando si usa un filesystem indicizzato a 64 bit) questo
+può non essere possibile lo standard POSIX ha introdotto le nuove funzioni
+\func{fgetpos} e \func{fsetpos}, che invece usano il nuovo tipo
+\type{fpos\_t}, ed i cui prototipi sono:
+\begin{functions}
+  \headdecl{stdio.h} 
   
+  \funcdecl{int fsetpos(FILE *stream, fpos\_t *pos)} Setta la posizione
+  corrente nello stream \param{stream} al valore specificato da \param{pos}.
+  
+  \funcdecl{int fgetpos(FILE *stream, fpos\_t *pos)} Scrive la posizione
+  corrente nello stream \param{stream} in \param{pos}.
+  
+  \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
+    errore.}
+\end{functions}
+
+In Linux, a partire dalle glibc 2.1, sono presenti anche le funzioni
+\func{fseeko} e \func{ftello}, assolutamente identiche alle precedenti ma con
+argomenti di tipo \type{off\_t} anziché di tipo \type{long int}.
+
 
 
 \section{Funzioni avanzate}
 \label{sec:file_stream_adv_func}
 
-In questa sezione esamineremo le funzioni che permettono di controllare
-alcune caratteristiche più particolari degli stream, come la lettura
-degli attributi, le modalità di bufferizzazione, etc.
+In questa sezione esamineremo alcune funzioni avanzate che permettono di
+eseguire operazioni particolari sugli stream, come leggerne gli attributi,
+controllarne le modalità di bufferizzazione, gestire direttamente i lock
+impliciti per la programmazione multi thread.
 
 
 \subsection{Le funzioni di controllo}
@@ -1198,7 +1317,7 @@ stream; questo pu
 \func{\_\_fwritable} i cui prototipi sono:
 \begin{functions}
   \headdecl{stdio\_ext.h}
-  \funcdecl{int \_\_freadable (FILE *stream)}
+  \funcdecl{int \_\_freadable(FILE *stream)}
   Restituisce un valore diverso da zero se \param{stream} consente la lettura.
 
   \funcdecl{int \_\_fwritable(FILE *stream)}  
@@ -1210,7 +1329,7 @@ Altre due funzioni, \func{\_\_freading} e \func{\_\_fwriting} servono ad un
 uso ancora più specialistico, il loro prototipo è: 
 \begin{functions}
   \headdecl{stdio\_ext.h}
-  \funcdecl{int \_\_freading (FILE *stream)}
+  \funcdecl{int \_\_freading(FILE *stream)}
   Restituisce un valore diverso da zero se \param{stream} è aperto in sola
   lettura o se l'ultima operazione è stata di lettura.
 
@@ -1235,8 +1354,99 @@ del buffer e del suo contenuto.
 \label{sec:file_buffering_ctrl}
 
 Come accennato in \secref{sec:file_buffering} le librerie definiscono una
-serie di funzioni che permettono di controllare il comportamento degli
-stream; se non si è 
+serie di funzioni che permettono di controllare il comportamento degli stream;
+se non si è specificato nulla la modalità di buffering viene decisa
+autonomamente sulla base del tipo di file sottostante, ed i buffer vengono
+allocati automaticamente.
+
+Però una volta che si sia aperto lo stream (ma prima di aver compiuto
+operazioni su di esso) è possibile intervenire sulle modalità di buffering; la
+funzione che permette di controllare la bufferizzazione è \func{setvbuf}, il
+suo prototipo è:
+\begin{prototype}{stdio.h}{int setvbuf(FILE *stream, char *buf, int mode, 
+    size\_t size)}
+  
+  Setta la bufferizzazione dello stream \param{stream} nella modalità indicata
+  da \param{mode}, usando \param{buf} come buffer di lunghezza \param{size}.
+  
+  \bodydesc{Restituisce zero in caso di successo, ed un valore qualunque in
+    caso di errore.}
+\end{prototype}
+
+La funzione permette di controllare tutti gli aspetti della bufferizzazione;
+l'utente può specificare un buffer da usare al posto di quello allocato dal
+sistema passandone alla funzione l'indirizzo in \param{buf} e la dimensione in
+\param{size}. 
+
+Ovviamente se si usa un buffer specificato dall'utente questo deve essere
+stato allocato e restare disponibile per tutto il tempo in cui si opera sullo
+stream. In genere conviene allocarlo con \func{malloc} e disallocarlo dopo la
+chiusura del file, ma fintanto che il file è usato all'interno di una
+funzione, può anche essere usata una variabile automatica; in genere è
+definita una macro \macro{BUFSIZ} che indica le dimensioni ottimali del
+buffer. Dato che la procedura è macchinosa e comporta dei rischi (come delle
+scritture accidentali sul buffer) è sempre meglio lasciare allocare il buffer
+alle funzioni di librerie, che sono in grado di farlo in maniera ottimale e
+trasparente all'utente.
+
+Per evitare il settaggio del buffer basta passare un valore \macro{NULL} per
+\param{buf} e la funzione ignorerà il parametro \param{size} usando il buffer
+allocato automaticamente dal sistema.  In questo modo si potrà comunque
+modificare la modalità di bufferizzazione, passando in \param{mode} uno degli
+opportuni valori elencati in \ntab; qualora si specifiche la modalità non
+bufferizzata i valori di \param{buf} e \param{size} vengono ignorati.
+
+\begin{table}[htb]
+  \centering
+    \begin{tabular}[c]{|l|l|}
+      \hline
+      \textbf{Valore} & \textbf{Modalità} \\
+      \hline
+      \hline
+      \macro{\_IONBF} & \textit{unbuffered}\\
+      \macro{\_IOLBF} & \textit{line buffered}\\
+      \macro{\_IOFBF} & \textit{fully buffered}\\
+      \hline
+    \end{tabular}
+  \label{tab:file_stream_buf_mode}
+  \caption{Valori del parametro \param{mode} di \func{setvbuf} 
+    per il settaggio delle modalità di bufferizzazione.}
+\end{table}
+
+Oltre a \func{setvbuf} le \acr{glibc} definiscono altre tre funzioni per la
+gestione della bufferizzazione di uno stream: \func{setbuf}, \func{setbuffer}
+e \func{setlinebuf}, i loro prototipi sono:
+\begin{functions}
+  \headdecl{stdio.h} 
+  
+  \funcdecl{void setbuf(FILE *stream, char *buf)} Disabilita la
+  bufferizzazione se \param{buf} è \macro{NULL}, altrimenti usa \param{buf}
+  come buffer di dimensione \macro{BUFSIZ} in modalità \textit{fully buffered}.
+  
+  \funcdecl{void setbuffer(FILE *stream, char *buf, size\_t size)} Disabilita
+  la bufferizzazione se \param{buf} è \macro{NULL}, altrimenti usa \param{buf}
+  come buffer di dimensione \param{size} in modalità \textit{fully buffered}.
+  
+  \funcdecl{void setlinebuf(FILE *stream)} Pone lo stream in modalità
+  \textit{line buffered}.
+\end{functions}
+\noindent tutte queste funzioni sono realizzate con opportune chiamate a
+\func{setvbuf} e sono definite solo per compatibilità con le vecchie librerie
+BSD.
+
+Sempre seguendo Solaris le \acr{glibc} provvedono alcune estensioni non
+standard che permettono di leggere le proprietà di bufferizzazione di uno
+stream; dette funzioni sono:
+\begin{functions}
+  \headdecl{stdio\_ext.h} 
+  
+  \funcdecl{int \_\_flbf(FILE *stream)} Restituisce un valore diverso da zero
+  se \param{stream} è in modalità \textit{line buffered}.
+  
+  \funcdecl{size\_t \_\_fbufsize(FILE *stream)} Restituisce le dimensioni del
+  buffer di \param{stream}.
+\end{functions}
+
 
 
 \subsection{Gli stream e i thread}
@@ -1248,8 +1458,19 @@ consapevoli delle possibili complicazioni anche quando non si usano i
 thread, dato che l'implementazione delle librerie è influenzata
 pesantemente dalle richieste necessarie per garantirne l'uso coi thread.
 
-
-
+Lo standard POSIX richiede che le operazioni sui file siano atomiche rispetto
+ai thread, per questo le operazioni sui buffer effettuate dalle funzioni di
+libreria durante la lettura e la scrittura di uno stream devono essere
+opportunamente protette (in quanto il sistema assicura l'atomicità solo per le
+system call). Questo viene fatto associando ad ogni stream un opportuno blocco
+che deve essere implicitamente acquisito prima dell'esecuzione di qualunque
+operazione.
+
+Ci sono comunque situazioni in cui questo non basta, come quando un thread
+necessita di compiere più di una operazione sullo stream atomicamente, per
+questo motivo le librerie provvedono anche delle funzioni che permettono la
+gestione esplicita dei blocchi sugli stream; queste funzioni sono disponibili
+definendo \macro{\_POSIX\_THREAD\_SAFE\_FUNCTIONS} ed i loro prototipi sono:
 \begin{functions}
   \headdecl{stdio.h}
   
@@ -1265,16 +1486,44 @@ pesantemente dalle richieste necessarie per garantirne l'uso coi thread.
   \funcdecl{void funlockfile(FILE *stream)} Rilascia il lock dello
   stream \param{stream}.
 \end{functions}
-
-
-\subsection{Dettagli dell'implementazione}
-\label{sec:file_stream_details}
-
-
-\subsection{File temporanei}
-\label{sec:file_temp_file}
-
-
-\subsection{Efficienza}
-\label{sec:file_stream_efficiency}
+\noindent con queste funzioni diventa possibile acquisire un blocco ed
+eseguire tutte le operazioni volute, per poi rilasciarlo. 
+
+Ma vista la complessità delle strutture di dati coinvolte, le operazioni di
+blocco non sono del tutto indolori, e quando il locking dello stream non è
+necessario (come in tutti i programmi che non usano i thread), tutta la
+procedura può comportare dei pesanti costi in termini di prestazioni. Per
+questo motivo abbiamo visto in come per tutte le funzioni di I/O non
+formattato esistano delle versioni \code{\_unlocked} (alcune previste dallo
+standard POSIX stesso, altre aggiunte come estensioni dalle \acr{glibc}) che
+possono essere usate in tutti questi casi\footnote{in certi casi dette
+  funzioni possono essere usate, visto che sono molto più efficiente, anche in
+  caso di necessità di locking, una volta che questo sia stato acquisito
+  manualmente.} dato che in molti casi (come per esempio \func{getc} e
+\func{putc}) queste versioni possono essere realizzate come macro, e sono
+pertanto in grado di garantire prestazione enormemente più elevate.
+
+La sostituzione di tutte le funzioni di I/O con le relative versioni
+\code{\_unlocked} in un programma che non usa i thread è però un lavoro
+abbastanza noioso, e che appesantisce il codice; per questo motivo le
+\acr{glibc} provvedono un'altra via per poter utilizzare disabilitare il
+locking, anch'essa mutuata da estensioni introdotte in Solaris, cioè l'uso
+della funzione \func{\_\_fsetlocking}, il cui prototipo è:
+\begin{prototype}{stdio\_ext.h}{int \_\_fsetlocking (FILE *stream, int type)}
+  Specifica o richiede a seconda del valore di \param{type} la modalità in cui
+  le operazioni di I/O su \param{stream} vengono effettuate rispetto
+  all'acquisizione implicita del blocco sullo stream.
+
+  \bodydesc{Restituisce lo stato di locking interno dello stream con uno dei
+  valori \macro{FSETLOCKING\_INTERNAL} o \macro{FSETLOCKING\_BYCALLER}.}
+\end{prototype}
+\noindent ed i valori possibili per \param{type} sono i seguenti:
+\begin{basedescript}{\desclabelwidth{4.0cm}}
+\item[\macro{FSETLOCKING\_INTERNAL}] Lo stream userà da ora in poi il blocco
+  implicito di default.
+\item[\macro{FSETLOCKING\_BYCALLER}] Al ritorno della funzione sarà l'utente a
+  dover gestire da solo il locking dello stream.
+\item[\macro{FSETLOCKING\_QUERY}] Restituisce lo stato corrente della modalità
+  di blocco dello stream.
+\end{basedescript}