-\begin{prototype}{stdio.h}{int fcloseall(void)}
- Chiude tutti gli \textit{stream}.
-
- \bodydesc{Restituisce 0 se non ci sono errori ed \val{EOF} altrimenti.}
-\end{prototype}
-\noindent la funzione esegue lo scarico dei dati bufferizzati in uscita
-e scarta quelli in ingresso, chiudendo tutti i file. Questa funzione è
-provvista solo per i casi di emergenza, quando si è verificato un errore
-ed il programma deve essere abortito, ma si vuole compiere qualche altra
-operazione dopo aver chiuso i file e prima di uscire (si ricordi quanto
-visto in sez.~\ref{sec:proc_conclusion}).
-
-
-\subsection{Lettura e scrittura su uno \textit{stream}}
-\label{sec:file_io}
-
-Una delle caratteristiche più utili dell'interfaccia degli \textit{stream} è
-la ricchezza delle funzioni disponibili per le operazioni di lettura e
-scrittura sui file. Sono infatti previste ben tre diverse modalità modalità di
-input/output non formattato:
-\begin{enumerate*}
-\item\textsl{binario} in cui legge/scrive un blocco di dati alla
- volta, vedi sez.~\ref{sec:file_binary_io}.
-\item\textsl{a caratteri} in cui si legge/scrive un carattere alla
- volta (con la bufferizzazione gestita automaticamente dalla libreria),
- vedi sez.~\ref{sec:file_char_io}.
-\item\textsl{di linea} in cui si legge/scrive una linea alla volta (terminata
- dal carattere di newline \verb|'\n'|), vedi sez.~\ref{sec:file_line_io}.
-\end{enumerate*}
-ed inoltre la modalità di input/output formattato.
-
-A differenza dell'interfaccia dei file descriptor, con gli \textit{stream} il
-raggiungimento della fine del file è considerato un errore, e viene
-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 \ctyp{int}) \val{EOF}\footnote{la costante deve essere
- negativa, le \acr{glibc} usano -1, altre implementazioni possono avere
- valori diversi.} definito anch'esso nell'header \headfile{stdlib.h}.
-
-Dato che le funzioni dell'interfaccia degli \textit{stream} sono funzioni di
-libreria che si appoggiano a delle system call, esse non impostano
-direttamente la variabile \var{errno}, che mantiene il valore impostato dalla
-system call che ha riportato l'errore.
-
-Siccome la condizione di end-of-file è anch'essa segnalata come errore, nasce
-il problema di come distinguerla da un errore effettivo; basarsi solo sul
-valore di ritorno della funzione e controllare il valore di \var{errno}
-infatti non basta, dato che quest'ultimo potrebbe essere stato impostato in
-una altra occasione, (si veda sez.~\ref{sec:sys_errno} per i dettagli del
-funzionamento di \var{errno}).
-
-Per questo motivo tutte le implementazioni delle librerie standard mantengono
-per ogni \textit{stream} almeno due flag all'interno dell'oggetto \type{FILE},
-il flag di \textit{end-of-file}, che segnala che si è raggiunta la fine del
-file in lettura, e quello di errore, che segnala la presenza di un qualche
-errore nelle operazioni di input/output; questi due flag possono essere
-riletti dalle funzioni \funcd{feof} e \funcd{ferror}, i cui prototipi sono:
-\begin{functions}
- \headdecl{stdio.h}
- \funcdecl{int feof(FILE *stream)}
- Controlla il flag di end-of-file di \param{stream}.
- \funcdecl{int ferror(FILE *stream)}
- Controlla il flag di errore di \param{stream}.
-
- \bodydesc{Entrambe le funzioni ritornano un valore diverso da zero se
- i relativi flag sono impostati.}
-\end{functions}
-\noindent si tenga presente comunque che la lettura di questi flag segnala
-soltanto che c'è stato un errore, o che si è raggiunta la fine del file in una
-qualunque operazione sullo \textit{stream}, il controllo quindi deve essere
-effettuato ogni volta che si chiama una funzione di libreria.
-
-Entrambi i flag (di errore e di end-of-file) possono essere cancellati usando
-la funzione \funcd{clearerr}, il cui prototipo è:
-\begin{prototype}{stdio.h}{void clearerr(FILE *stream)}
- Cancella i flag di errore ed \textit{end-of-file} di \param{stream}.
-\end{prototype}
-\noindent in genere si usa questa funzione una volta che si sia identificata e
-corretta la causa di un errore per evitare di mantenere i flag attivi, così da
-poter rilevare una successiva ulteriore condizione di errore. Di questa
-funzione esiste una analoga \funcm{clearerr\_unlocked} che non esegue il
-blocco dello \textit{stream} (vedi sez.~\ref{sec:file_stream_thread}).
+
+\begin{funcproto}{
+\fhead{stdio.h}
+\fdecl{int fcloseall(void)}
+\fdesc{Chiude tutti gli \textit{stream}.}
+}
+
+{La funzione ritorna $0$ in caso di successo e \val{EOF} per un errore, nel
+ qual caso \var{errno} assumerà gli stessi valori di \func{fclose}.}
+\end{funcproto}
+
+La funzione esegue lo scarico dei dati bufferizzati in uscita e scarta quelli
+in ingresso, chiudendo tutti i file. Questa funzione è provvista solo per i
+casi di emergenza, quando si è verificato un errore ed il programma deve
+essere abortito, ma si vuole compiere qualche altra operazione dopo aver
+chiuso i file e prima di uscire (si ricordi quanto visto in
+sez.~\ref{sec:proc_conclusion}).
+
+
+\subsection{Gestione dell'I/O e posizionamento su uno \textit{stream}}
+ \label{sec:file_io}
+
+ Una delle caratteristiche più utili dell'interfaccia degli \textit{stream} è
+ la ricchezza delle funzioni disponibili per le operazioni di lettura e
+ scrittura sui file. Sono infatti previste ben tre diverse modalità modalità di
+ input/output non formattato:
+ \begin{itemize}
+ \item\textsl{binario} in cui si leggono e scrivono blocchi di dati di
+ dimensione arbitraria, (analogo della modalità ordinaria dell'I/O sui file
+ descriptor), trattato in sez.~\ref{sec:file_binary_io}.
+ \item\textsl{a caratteri} in cui si legge e scrive un carattere alla volta,
+ con la bufferizzazione che viene gestita automaticamente dalla libreria,
+ trattato in sez.~\ref{sec:file_char_io}.
+ \item\textsl{di linea} in cui si legge e scrive una linea alla volta,
+ (terminata dal carattere di newline \verb|'\n'|), trattato in
+ sez.~\ref{sec:file_line_io}.
+ \end{itemize}
+ a cui si aggiunge la modalità di input/output formattato, trattato in
+ sez.~\ref{sec:file_formatted_io}.
+
+ Ognuna di queste modalità utilizza per l'I/O delle funzioni specifiche che
+ vedremo nelle sezioni citate, affronteremo qui tutte gli argomenti e le
+ funzioni che si applicano in generale a tutte le modalità di I/O.
+
+ A differenza di quanto avviene con l'interfaccia dei file descriptor, con gli
+ \textit{stream} il raggiungimento della fine del file viene considerato un
+ errore, e viene 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 \ctyp{int}) \val{EOF} definito anch'esso nell'header
+ \headfile{stdlib.h}. La costante deve essere negativa perché in molte
+ funzioni un valore positivo indica la quantità di dati scritti, le
+ \acr{glibc} usano il valore $-1$, ma altre implementazioni possono avere
+ valori diversi.
+
+ Dato che le funzioni dell'interfaccia degli \textit{stream} sono funzioni di
+ libreria che si appoggiano a delle \textit{system call}, esse non impostano
+ direttamente la variabile \var{errno}, che mantiene sempre il valore
+ impostato dalla \textit{system call} invocata internamente che ha riportato
+ l'errore.
+
+ Siccome la condizione di \textit{end-of-file} è anch'essa segnalata come
+ errore, nasce il problema di come distinguerla da un errore effettivo;
+ basarsi solo sul valore di ritorno della funzione e controllare il valore di
+ \var{errno} infatti non basta, dato che quest'ultimo potrebbe essere stato
+ impostato in una altra occasione, (si veda sez.~\ref{sec:sys_errno} per i
+ dettagli del funzionamento di \var{errno}).
+
+ Per questo motivo tutte le implementazioni delle librerie standard mantengono
+ per ogni \textit{stream} almeno due flag all'interno dell'oggetto \type{FILE},
+ il flag di \textit{end-of-file}, che segnala che si è raggiunta la fine del
+ file in lettura, e quello di errore, che segnala la presenza di un qualche
+ errore nelle operazioni di input/output; questi due flag possono essere
+ riletti dalle funzioni \funcd{feof} e \funcd{ferror}, i cui prototipi sono:
+
+\begin{funcproto}{
+\fhead{stdio.h}
+\fdecl{int feof(FILE *stream)}
+\fdesc{Controlla il flag di \textit{end-of-file} di uno \textit{stream}.}
+\fdecl{int ferror(FILE *stream)}
+\fdesc{Controlla il flag di errore di uno \textit{stream}.}
+}
+
+{Le funzioni ritornano un valore diverso da zero se i relativi flag sono
+ impostati, e non prevedono condizioni di errore.}
+\end{funcproto}
+
+Si tenga presente comunque che la lettura di questi flag segnala soltanto che
+c'è stato un errore o che si è raggiunta la fine del file in una qualunque
+operazione sullo \textit{stream}, il controllo su quanto avvenuto deve quindi
+essere effettuato ogni volta che si chiama una funzione di libreria.
+
+Entrambi i flag (di errore e di \textit{end-of-file}) possono essere
+cancellati usando la funzione \funcd{clearerr}, il cui prototipo è:
+
+\begin{funcproto}{
+\fhead{stdio.h}
+\fdecl{void clearerr(FILE *stream)}
+\fdesc{Cancella i flag di errore ed \textit{end-of-file} di uno
+ \textit{stream}.}
+}
+
+{La funzione non ritorna nulla e prevede condizioni di errore.}
+\end{funcproto}
+
+In genere si usa questa funzione una volta che si sia identificata e corretta
+la causa di un errore per evitare di mantenere i flag attivi, così da poter
+rilevare una successiva ulteriore condizione di errore. Di questa funzione
+esiste una analoga \funcm{clearerr\_unlocked} (con lo stesso argomento e
+stessi valori di ritorno) che non esegue il blocco dello \textit{stream}
+(tratteremo il significato di blocco di uno \textit{stream} in
+sez.~\ref{sec:file_stream_thread}).
+
+Come per i file descriptor anche per gli \textit{stream} è possibile spostarsi
+all'interno di un file per effettuare operazioni di lettura o scrittura in un
+punto prestabilito, sempre che l'operazione di riposizionamento sia supportata
+dal file sottostante lo \textit{stream}, nel caso cioè in cui si ha a che
+fare con quello che viene detto un file ad \textsl{accesso casuale}. Dato che
+in un sistema Unix esistono vari tipi di file, come le fifo ed i
+\index{file!di~dispositivo} file di dispositivo (ad esempio i terminali), non
+è scontato che questo sia vero in generale, pur essendolo sempre nel caso di
+file di dati.
+
+Con Linux ed in generale in ogni sistema unix-like la posizione nel file, come
+abbiamo già visto in sez.~\ref{sec:file_lseek}, è espressa da un intero
+positivo, rappresentato dal tipo \type{off\_t}. Il problema è che alcune delle
+funzioni usate per il riposizionamento sugli \textit{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 nel VMS dove
+esistono i file a record (in cui cioè l'I/O avviene per blocchi, i record, di
+dimensione fissa), essa può essere rappresentata come un numero di record, più
+l'offset rispetto al record corrente.
+
+Tutto questo comporta la presenza di diverse funzioni che eseguono
+sostanzialmente le stesse operazioni, ma usano argomenti di tipo diverso. Le
+funzioni tradizionali usate per eseguire una modifica della posizione corrente
+sul file con uno \textit{stream} sono \funcd{fseek} e \funcd{rewind}, i
+rispettivi prototipi sono:
+
+\begin{funcproto}{
+\fhead{stdio.h}
+\fdecl{int fseek(FILE *stream, long offset, int whence)}
+\fdesc{Sposta la posizione nello \textit{stream}.}
+\fdecl{void rewind(FILE *stream)}
+\fdesc{Riporta la posizione nello \textit{stream} all'inizio del file.}
+}
+
+{La funzione \func{fseek} ritorna $0$ in caso di successo e $-1$ per un
+ errore, nel qual caso \var{errno} assumerà i valori di \func{lseek},
+ \func{rewind} non ritorna nulla e non ha condizioni di errore.}
+\end{funcproto}
+
+L'uso di \func{fseek} è del tutto analogo a quello di \func{lseek} per i file
+descriptor (vedi sez.~\ref{sec:file_lseek}). Anche gli argomenti, a parte il
+tipo, hanno esattamente lo stesso significato. In particolare \param{whence}
+deve assumere gli stessi valori già visti nella prima parte di
+tab.~\ref{tab:lseek_whence_values}. La funzione restituisce 0 in caso di
+successo e -1 in caso di errore.
+
+La funzione \func{rewind} riporta semplicemente la posizione corrente sul file
+all'inizio dello \textit{stream}, ma non è esattamente equivalente ad aver
+eseguito una \code{fseek(stream, 0L, SEEK\_SET)}, in quanto con l'uso della
+funzione vengono cancellati anche i flag di errore e di fine del file.
+
+Per ottenere la posizione corrente sul file di uno \textit{stream} lo standard
+ANSI C prescrive l'uso della funzione \funcd{ftell}, il cui prototipo è:
+
+\begin{funcproto}{
+\fhead{stdio.h}
+\fdecl{long ftell(FILE *stream)}
+\fdesc{Legge la posizione attuale nello \textit{stream}.}
+}
+
+{La funzione ritorna la posizione corrente in caso di successo e $-1$ per un
+ errore, nel qual caso \var{errno} assumerà i valori di \func{lseek}.}
+\end{funcproto}
+
+\noindent che restituisce la posizione come numero di byte dall'inizio dello
+\textit{stream}.
+
+Sia \func{fseek} che \func{ftell} esprimono la posizione nel file con un
+intero di tipo \ctyp{long}. Dato che in certi casi, ad esempio quando si usa
+un filesystem indicizzato a 64 bit su una macchina con architettura a 32 bit,
+questo può non essere possibile lo standard POSIX ha introdotto le nuove
+funzioni \funcd{fgetpos} e \funcd{fsetpos}, che invece usano il nuovo tipo
+\type{fpos\_t}, ed i cui prototipi sono:
+
+\begin{funcproto}{
+\fhead{stdio.h}
+\fdecl{int fsetpos(FILE *stream, fpos\_t *pos)}
+\fdesc{Imposta la posizione corrente sul file.}
+\fdecl{int fgetpos(FILE *stream, fpos\_t *pos)}
+\fdesc{Legge la posizione corrente sul file.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà i valori di \func{lseek}.}
+\end{funcproto}
+
+In Linux, a partire dalle glibc 2.1, sono presenti anche le due funzioni
+\func{fseeko} e \func{ftello}, che sono assolutamente identiche alle
+precedenti \func{fseek} e \func{ftell} ma hanno argomenti di tipo
+\type{off\_t} anziché di tipo \ctyp{long int}. Dato che \ctyp{long} è nella
+gran parte dei casi un intero a 32 bit, questo diventa un problema quando la
+posizione sul file viene espressa con un valore a 64 bit come accade nei
+sistemi più moderni.
+
+% TODO: mettere prototipi espliciti fseeko e ftello o menzione?
+