Si prosegue con nanosleep ...

[gapil.git] / filestd.tex

diff --git a/filestd.tex b/filestd.tex
index 1c5c288c4cdc0d4be3f61cef7bba1cf4e2255808..5e6cdecf0f569fa061ca00e40958b9d2cff8343c 100644 (file)
--- a/filestd.tex
+++ b/filestd.tex
@@ -30,13 +30,12 @@ Come pi
 basso livello, che non provvede nessuna forma di formattazione dei dati e
 nessuna forma di bufferizzazione per ottimizzare le operazioni di I/O.
 
 basso livello, che non provvede nessuna forma di formattazione dei dati e
 nessuna forma di bufferizzazione per ottimizzare le operazioni di I/O.
 

-In \textit{Advanced Programming in the Unix Environment} Stevens descrive una
-serie di test sull'influenza delle dimensioni del blocco di dati (il parametro
-\param{buf} di \func{read} e \func{write}) nell'efficienza nelle operazioni di
-I/O con i file descriptor, evidenziando come le prestazioni ottimali si
-ottengano a partire da dimensioni del buffer dei dati pari a quelle dei
-blocchi del filesystem (il valore dato dal campo \var{st\_blksize} di
-\var{fstat}).
+In \cite{APUE} Stevens descrive una serie di test sull'influenza delle
+dimensioni del blocco di dati (il parametro \param{buf} di \func{read} e
+\func{write}) nell'efficienza nelle operazioni di I/O con i file descriptor,
+evidenziando come le prestazioni ottimali si ottengano a partire da dimensioni
+del buffer dei dati pari a quelle dei blocchi del filesystem (il valore dato
+dal campo \var{st\_blksize} di \var{fstat}).

 
 Se il programmatore non si cura di effettuare le operazioni in blocchi di
 dimensioni adeguate, le prestazioni sono inferiori.  La caratteristica
 
 Se il programmatore non si cura di effettuare le operazioni in blocchi di
 dimensioni adeguate, le prestazioni sono inferiori.  La caratteristica


@@ -88,27 +87,27 @@ rappresentano i canali standard di input/output prestabiliti; anche
 questi tre stream sono identificabili attraverso dei nomi simbolici
 definiti nell'header \file{stdio.h} che sono:
 
 questi tre stream sono identificabili attraverso dei nomi simbolici
 definiti nell'header \file{stdio.h} che sono:
 

-\begin{itemize}
-\item \var{FILE *stdin} Lo \textit{standard input} cioè lo stream da
+\begin{basedescript}{\desclabelwidth{3.0cm}}
+\item[\var{FILE *stdin}] Lo \textit{standard input} cioè lo stream da

   cui il processo riceve ordinariamente i dati in ingresso. Normalmente
   è associato dalla shell all'input del terminale e prende i caratteri
   dalla tastiera.
   cui il processo riceve ordinariamente i dati in ingresso. Normalmente
   è associato dalla shell all'input del terminale e prende i caratteri
   dalla tastiera.

-\item \var{FILE *stdout} Lo \textit{standard input} cioè lo stream su
+\item[\var{FILE *stdout}] Lo \textit{standard input} cioè lo stream su

   cui il processo invia ordinariamente i dati in uscita. Normalmente è
   associato dalla shell all'output del terminale e scrive sullo schermo.
   cui il processo invia ordinariamente i dati in uscita. Normalmente è
   associato dalla shell all'output del terminale e scrive sullo schermo.

-\item \var{FILE *stderr} Lo \textit{standard input} cioè lo stream su
+\item[\var{FILE *stderr}] Lo \textit{standard input} cioè lo stream su

   cui il processo è supposto inviare i messaggi di errore. Normalmente
   anch'esso è associato dalla shell all'output del terminale e scrive
   sullo schermo.
   cui il processo è supposto inviare i messaggi di errore. Normalmente
   anch'esso è associato dalla shell all'output del terminale e scrive
   sullo schermo.

-\end{itemize}
+\end{basedescript}

 
 Nelle \acr{glibc} \var{stdin}, \var{stdout} e \var{stderr} sono
 effettivamente tre variabili di tipo \type{FILE *} che possono essere
 usate come tutte le altre, ad esempio si può effettuare una redirezione
 dell'output di un programma con il semplice codice:
 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
 
 Nelle \acr{glibc} \var{stdin}, \var{stdout} e \var{stderr} sono
 effettivamente tre variabili di tipo \type{FILE *} che possono essere
 usate come tutte le altre, ad esempio si può effettuare una redirezione
 dell'output di un programma con il semplice codice:
 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}

-    fclose (stdout);
-    stdout = fopen ("standard-output-file", "w");
+    fclose(stdout);
+    stdout = fopen("standard-output-file", "w");

 \end{lstlisting}
 ma in altri sistemi queste variabili possono essere definite da macro, e
 se si hanno problemi di portabilità e si vuole essere sicuri, diventa
 \end{lstlisting}
 ma in altri sistemi queste variabili possono essere definite da macro, e
 se si hanno problemi di portabilità e si vuole essere sicuri, diventa


@@ -209,10 +208,10 @@ corrente in uno stream.
 \subsection{Apertura e chiusura di uno stream}
 \label{sec:file_fopen}
 
 \subsection{Apertura e chiusura di uno stream}
 \label{sec:file_fopen}
 

-Le funzioni che si possono usare per aprire uno stream sono solo
-tre\footnote{\func{fopen} e \func{freopen} fanno parte dello standard
-  ANSI C, \func{fdopen} è parte dello standard POSIX.1.}, i loro
-prototipi sono:
+Le funzioni che si possono usare per aprire uno stream sono solo tre:
+\func{fopen}, \func{fdopen} e \func{freopen},\footnote{\func{fopen} e
+  \func{freopen} fanno parte dello standard ANSI C, \func{fdopen} è parte
+  dello standard POSIX.1.} i loro prototipi sono:

 \begin{functions}
   \headdecl{stdio.h}
   \funcdecl{FILE *fopen(const char *path, const char *mode)}
 \begin{functions}
   \headdecl{stdio.h}
   \funcdecl{FILE *fopen(const char *path, const char *mode)}


@@ -253,6 +252,7 @@ possono essere aperti con le funzioni delle librerie standard del C.
 
 \begin{table}[htb]
   \centering
 
 \begin{table}[htb]
   \centering

+  \footnotesize

   \begin{tabular}[c]{|l|p{8cm}|}
     \hline
     \textbf{Valore} & \textbf{Significato}\\
   \begin{tabular}[c]{|l|p{8cm}|}
     \hline
     \textbf{Valore} & \textbf{Significato}\\


@@ -275,6 +275,9 @@ possono essere aperti con le funzioni delle librerie standard del C.
     \texttt{a+} & Il file viene aperto (o creato se non esiste) in
     \textit{append mode}, l'accesso viene posto in lettura e scrittura. \\
     \hline
     \texttt{a+} & Il file viene aperto (o creato se non esiste) in
     \textit{append mode}, l'accesso viene posto in lettura e scrittura. \\
     \hline

+    \texttt{b} & specifica che il file è binario, non ha alcun effetto. \\
+    \texttt{x} & la apertura fallisce se il file esiste già. \\
+    \hline

   \end{tabular}
   \caption{Modalità di apertura di uno stream dello standard ANSI C che
     sono sempre presenti in qualunque sistema POSIX}
   \end{tabular}
   \caption{Modalità di apertura di uno stream dello standard ANSI C che
     sono sempre presenti in qualunque sistema POSIX}


@@ -304,13 +307,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.
 
 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
 
 I nuovi file saranno creati secondo quanto visto in
 \secref{sec:file_ownership} ed avranno i permessi di accesso settati al


@@ -320,7 +322,7 @@ processo (si veda \secref{sec:file_umask}).
 
 In caso di file aperti in lettura e scrittura occorre ricordarsi che c'è
 di messo una bufferizzazione; per questo motivo lo standard ANSI C
 
 In caso di file aperti in lettura e scrittura occorre ricordarsi che c'è
 di messo una bufferizzazione; per questo motivo lo standard ANSI C

-richiede che ci sia una operazione di posizionamento fra una operazione
+richiede che ci sia un'operazione di posizionamento fra un'operazione

 di output ed una di input o viceversa (eccetto il caso in cui l'input ha
 incontrato la fine del file), altrimenti una lettura può ritornare anche
 il risultato di scritture precedenti l'ultima effettuata. 
 di output ed una di input o viceversa (eccetto il caso in cui l'input ha
 incontrato la fine del file), altrimenti una lettura può ritornare anche
 il risultato di scritture precedenti l'ultima effettuata. 


@@ -330,7 +332,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
 \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 \code{fseek(file, 0, SEEK\_CUR)} è
+un'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
 sufficiente a garantire la sincronizzazione.
 
 Una volta aperto lo stream, si può cambiare la modalità di bufferizzazione


@@ -355,9 +357,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}).
 
 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. 
   
 \begin{prototype}{stdio.h}{int fcloseall(void)}
   Chiude tutti gli stream. 
   


@@ -437,8 +439,10 @@ la funzione \func{clearerr}, il cui prototipo 
   Cancella i flag di errore ed end-of-file di \param{stream}. 
 \end{prototype}
 \noindent in genere si usa questa funziona una volta che si sia identificata e
   Cancella i flag di errore ed end-of-file di \param{stream}. 
 \end{prototype}
 \noindent in genere si usa questa funziona 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.
+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 \func{clearerr\_unlocked} che non esegue il blocco
+dello stream (vedi \secref{sec:file_stream_thread}).

 
 
 \subsection{Input/output binario}
 
 
 \subsection{Input/output binario}


@@ -470,6 +474,7 @@ In genere si usano queste funzioni quando si devono trasferire su file
 blocchi di dati binari in maniera compatta e veloce; un primo caso di uso
 tipico è quello in cui si salva un vettore (o un certo numero dei suoi
 elementi) con una chiamata del tipo:
 blocchi di dati binari in maniera compatta e veloce; un primo caso di uso
 tipico è quello in cui si salva un vettore (o un certo numero dei suoi
 elementi) con una chiamata del tipo:

+\footnotesize

 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
 int WriteVect(FILE *stream, double *vec, size_t nelem) 
 {
 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
 int WriteVect(FILE *stream, double *vec, size_t nelem) 
 {


@@ -481,18 +486,20 @@ int WriteVect(FILE *stream, double *vec, size_t nelem)
     return nread;
 }
 \end{lstlisting}
     return nread;
 }
 \end{lstlisting}

+\normalsize

 in questo caso devono essere specificate le dimensioni di ciascun
 elemento ed il numero di quelli che si vogliono scrivere. Un secondo
 caso è invece quello in cui si vuole trasferire su file una struttura;
 si avrà allora una chiamata tipo:
 in questo caso devono essere specificate le dimensioni di ciascun
 elemento ed il numero di quelli che si vogliono scrivere. Un secondo
 caso è invece quello in cui si vuole trasferire su file una struttura;
 si avrà allora una chiamata tipo:

+\footnotesize

 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
 struct histogram {
     int nbins; 
     double max, min;
 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
 struct histogram {
     int nbins; 
     double max, min;

-    double * bin;
+    double *bin;

 } histo; 
 
 } 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");
 {
     if ( fwrite(vec, sizeof(*histo), 1, stream) !=1) {
         perror("Write error");


@@ -500,6 +507,7 @@ int WriteStruct(FILE * stream, struct histogram * histo, size_t nelem)
     return nread;
 }
 \end{lstlisting}
     return nread;
 }
 \end{lstlisting}

+\normalsize

 in cui si specifica la dimensione dell'intera struttura ed un solo
 elemento. 
 
 in cui si specifica la dimensione dell'intera struttura ed un solo
 elemento. 
 


@@ -546,10 +554,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
 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}
 \begin{functions}

-  \headdecl{stdio.h} 
+  \headdecl{stdio.h}

   
   \funcdecl{size\_t fread\_unlocked(void *ptr, size\_t size, size\_t
     nmemb, FILE *stream)}
   
   \funcdecl{size\_t fread\_unlocked(void *ptr, size\_t size, size\_t
     nmemb, FILE *stream)}


@@ -589,14 +596,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
 
 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.
 
 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
 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


@@ -745,14 +752,13 @@ prototipi sono:
     di successo o \macro{NULL} in caso di errore.}
 \end{functions}
 
     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
 la stringa letta superi le dimensioni del buffer, si avrà un
 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
 la stringa letta superi le dimensioni del buffer, si avrà un


@@ -794,13 +800,13 @@ rispettivi prototipi sono:
     successo o \macro{EOF} in caso di errore.}
 \end{functions}
 
     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:
 
 Come per le funzioni di input/output a caratteri esistono le estensioni
 per leggere e scrivere caratteri estesi, i loro prototipi sono:


@@ -953,14 +959,11 @@ dell'alternativa:
 
 La parte più complessa di queste funzioni è il formato della stringa
 \param{format} che indica le conversioni da fare, da cui poi deriva il numero
 
 La parte più complessa di queste funzioni è il formato della stringa
 \param{format} che indica le conversioni da fare, da cui poi deriva il numero

-dei parametri che dovranno essere passati a seguire. La stringa è costituita
-da caratteri normali (tutti eccetto \texttt{\%}), che vengono passati
-invariati all'output, e da direttive di conversione, in cui devono essere
-sempre presenti il carattere \texttt{\%}, che introduce la direttiva, ed uno
-degli specificatori di conversione (riportati in \ntab) che la conclude. 
+dei parametri che dovranno essere passati a seguire. 

 
 \begin{table}[htb]
   \centering
 
 \begin{table}[htb]
   \centering

+  \footnotesize

   \begin{tabular}[c]{|l|l|p{10cm}|}
     \hline
     \textbf{Valore} & \textbf{Tipo} & \textbf{Significato} \\
   \begin{tabular}[c]{|l|l|p{10cm}|}
     \hline
     \textbf{Valore} & \textbf{Tipo} & \textbf{Significato} \\


@@ -1002,6 +1005,32 @@ degli specificatori di conversione (riportati in \ntab) che la conclude.
   \label{tab:file_format_spec}
 \end{table}
 
   \label{tab:file_format_spec}
 \end{table}
 

+La stringa è costituita da caratteri normali (tutti eccetto \texttt{\%}), che
+vengono passati invariati all'output, e da direttive di conversione, in cui
+devono essere sempre presenti il carattere \texttt{\%}, che introduce la
+direttiva, ed uno degli specificatori di conversione (riportati in
+\tabref{tab:file_format_spec}) che la conclude.
+
+\begin{table}[htb]
+  \centering
+  \footnotesize
+  \begin{tabular}[c]{|l|p{10cm}|}
+    \hline
+    \textbf{Valore} & \textbf{Significato}\\
+    \hline
+    \hline
+    \cmd{\#} & Chiede la conversione in forma alternativa. \\
+    \cmd{0}  & La conversione è riempita con zeri alla sinistra del valore.\\
+    \cmd{-}  & La conversione viene allineata a sinistra sul bordo del campo.\\
+    \cmd{' '}& Mette uno spazio prima di un numero con segno di valore 
+               positivo\\
+    \cmd{+}  & Mette sempre il segno ($+$ o $-$) prima di un numero.\\
+    \hline
+  \end{tabular}
+  \caption{I valori dei flag per il formato di \func{printf}}
+  \label{tab:file_format_flag}
+\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
 generale essa è sempre del tipo:
 Il formato di una direttiva di conversione prevede una serie di possibili
 elementi opzionali oltre al \cmd{\%} e allo specificatore di conversione. In
 generale essa è sempre del tipo:


@@ -1027,30 +1056,12 @@ questo ordine:
 \end{itemize*}
 
 
 \end{itemize*}
 
 

-\begin{table}[htb]
-  \centering
-  \begin{tabular}[c]{|l|p{10cm}|}
-    \hline
-    \textbf{Valore} & \textbf{Significato}\\
-    \hline
-    \hline
-    \cmd{\#} & Chiede la conversione in forma alternativa. \\
-    \cmd{0}  & La conversione è riempita con zeri alla sinistra del valore.\\
-    \cmd{-}  & La conversione viene allineata a sinistra sul bordo del campo.\\
-    \cmd{' '}& Mette uno spazio prima di un numero con segno di valore 
-               positivo\\
-    \cmd{+}  & Mette sempre il segno ($+$ o $-$) prima di un numero.\\
-    \hline
-  \end{tabular}
-  \caption{I valori dei flag per il formato di \func{printf}}
-  \label{tab:file_format_flag}
-\end{table}
-

 Dettagli ulteriori sulle varie opzioni possono essere trovati nella man page
 di \func{printf} e nella documentazione delle \acr{glibc}.
 
 \begin{table}[htb]
   \centering
 Dettagli ulteriori sulle varie opzioni possono essere trovati nella man page
 di \func{printf} e nella documentazione delle \acr{glibc}.
 
 \begin{table}[htb]
   \centering

+  \footnotesize

   \begin{tabular}[c]{|l|p{10cm}|}
     \hline
     \textbf{Valore} & \textbf{Significato} \\
   \begin{tabular}[c]{|l|p{10cm}|}
     \hline
     \textbf{Valore} & \textbf{Significato} \\


@@ -1287,9 +1298,10 @@ pu
     errore.}
 \end{functions}
 
     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}.
+In Linux, a partire dalle glibc 2.1, sono presenti anche le due funzioni
+\func{fseeko} e \func{ftello}, che assolutamente identiche alle precedenti
+\func{fseek} e \func{ftell} ma hanno argomenti di tipo \type{off\_t} anziché
+di tipo \type{long int}.

 
 
 
 
 
 


@@ -1298,24 +1310,39 @@ argomenti di tipo \type{off\_t} anzich
 
 In questa sezione esamineremo alcune funzioni avanzate che permettono di
 eseguire operazioni particolari sugli stream, come leggerne gli attributi,
 
 In questa sezione esamineremo alcune funzioni avanzate che permettono di
 eseguire operazioni particolari sugli stream, come leggerne gli attributi,

-controllarne le modalità di bufferizzazione, ecc.
+controllarne le modalità di bufferizzazione, gestire direttamente i lock
+impliciti per la programmazione multi thread.

 
 
 \subsection{Le funzioni di controllo}
 \label{sec:file_stream_cntrl}
 
 Al contrario di quanto avviene con i file descriptor le librerie standard del
 
 
 \subsection{Le funzioni di controllo}
 \label{sec:file_stream_cntrl}
 
 Al contrario di quanto avviene con i file descriptor le librerie standard del

-C non prevedono nessuna funzione come la \func{fcntl} per la lettura degli
-attributi degli stream; le \acr{glibc} però supportano alcune estensioni
-derivate da Solaris, che permettono di ottenere informazioni utili.
-
-In certi casi può essere necessario sapere se un certo stream è accessibile in
-lettura o scrittura. In genere questa informazione non è disponibile, e si
-deve ricordare come il file è stato aperto. La cosa può essere complessa se le
-operazioni vengono effettuate in una subroutine, che a questo punto
-necessiterà di informazioni aggiuntive rispetto al semplice puntatore allo
-stream; questo può essere evitato con le due funzioni \func{\_\_freadable} e
-\func{\_\_fwritable} i cui prototipi sono:
+C non prevedono nessuna funzione come la \func{fcntl} per il controllo degli
+attributi dei file. Però siccome ogni stream si appoggia ad un file descriptor
+si può usare la funzione \func{fileno} per ottenere quest'ultimo, il prototipo
+della funzione è:
+\begin{prototype}{stdio.h}{int fileno(FILE *stream)}
+  Legge il file descriptor sottostante lo stream \param{stream}.
+  
+  \bodydesc{Restituisce il numero del file descriptor in caso di successo, e
+    -1 qualora \param{stream} non sia valido, nel qual caso setta \var{errno}
+  a \macro{EBADF}.}
+\end{prototype}
+\noindent ed in questo modo diventa possibile usare direttamente \func{fcntl}.
+
+Questo permette di accedere agli attributi del file descriptor sottostante lo
+stream, ma non ci da nessuna informazione riguardo alle proprietà dello stream
+medesimo.  Le \acr{glibc} però supportano alcune estensioni derivate da
+Solaris, che permettono di ottenere informazioni utili.
+
+Ad esempio in certi casi può essere necessario sapere se un certo stream è
+accessibile in lettura o scrittura. In genere questa informazione non è
+disponibile, e si deve ricordare come il file è stato aperto. La cosa può
+essere complessa se le operazioni vengono effettuate in una subroutine, che a
+questo punto necessiterà di informazioni aggiuntive rispetto al semplice
+puntatore allo stream; questo può essere evitato con le due funzioni
+\func{\_\_freadable} e \func{\_\_fwritable} i cui prototipi sono:

 \begin{functions}
   \headdecl{stdio\_ext.h}
   \funcdecl{int \_\_freadable(FILE *stream)}
 \begin{functions}
   \headdecl{stdio\_ext.h}
   \funcdecl{int \_\_freadable(FILE *stream)}


@@ -1325,9 +1352,12 @@ stream; questo pu
   Restituisce un valore diverso da zero se \param{stream} consente la
   scrittura.
 \end{functions}
   Restituisce un valore diverso da zero se \param{stream} consente la
   scrittura.
 \end{functions}

+\noindent che permettono di ottenere questa informazione.

 
 

-Altre due funzioni, \func{\_\_freading} e \func{\_\_fwriting} servono ad un
-uso ancora più specialistico, il loro prototipo è: 
+La conoscenza dell'ultima operazione effettuata su uno stream aperto è utile
+in quanto permette di trarre conclusioni sullo stato del buffer e del suo
+contenuto. Altre due funzioni, \func{\_\_freading} e \func{\_\_fwriting}
+servono a tale scopo, il loro prototipo è:

 \begin{functions}
   \headdecl{stdio\_ext.h}
   \funcdecl{int \_\_freading(FILE *stream)}
 \begin{functions}
   \headdecl{stdio\_ext.h}
   \funcdecl{int \_\_freading(FILE *stream)}


@@ -1339,16 +1369,12 @@ uso ancora pi
   scrittura o se l'ultima operazione è stata di scrittura.
 \end{functions}
 
   scrittura o se l'ultima operazione è stata di scrittura.
 \end{functions}
 

-Le due funzioni hanno lo scopo di determinare di che tipo è stata l'ultima
+Le due funzioni permettono di determinare di che tipo è stata l'ultima

 operazione eseguita su uno stream aperto in lettura/scrittura; ovviamente se
 uno stream è aperto in sola lettura (o sola scrittura) la modalità dell'ultima
 operazione è sempre determinata; l'unica ambiguità è quando non sono state
 operazione eseguita su uno stream aperto in lettura/scrittura; ovviamente se
 uno stream è aperto in sola lettura (o sola scrittura) la modalità dell'ultima
 operazione è sempre determinata; l'unica ambiguità è quando non sono state

-ancora eseguite operazioni, in questo caso le funzioni rispondono come se
-una operazione ci fosse comunque stata.
-
-La conoscenza dell'ultima operazione effettuata su uno stream aperto in
-lettura/scrittura è utile in quanto permette di trarre conclusioni sullo stato
-del buffer e del suo contenuto.
+ancora eseguite operazioni, in questo caso le funzioni rispondono come se una
+operazione ci fosse comunque stata.

 
 
 \subsection{Il controllo della bufferizzazione}
 
 
 \subsection{Il controllo della bufferizzazione}


@@ -1371,7 +1397,7 @@ suo prototipo 
   da \param{mode}, usando \param{buf} come buffer di lunghezza \param{size}.
   
   \bodydesc{Restituisce zero in caso di successo, ed un valore qualunque in
   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.}
+    caso di errore, nel qual caso \var{errno} viene settata opportunamente.}

 \end{prototype}
 
 La funzione permette di controllare tutti gli aspetti della bufferizzazione;
 \end{prototype}
 
 La funzione permette di controllare tutti gli aspetti della bufferizzazione;


@@ -1382,23 +1408,25 @@ sistema passandone alla funzione l'indirizzo in \param{buf} e la dimensione in
 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
 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.
+chiusura del file; ma fintanto che il file è usato all'interno di una
+funzione, può anche essere usata una variabile automatica. In \file{stdio.h}
+definita la macro \macro{BUFSIZ}, che indica le dimensioni generiche del
+buffer di uno stream; queste vengono usate dalla funzione \func{setbuf},
+questa però non è detto corrisponda in tutti i casi al valore ottimale (che
+può variare a seconda del dispositivo).
+
+Dato che la procedura di allocazione manuale è macchinosa, comporta dei rischi
+(come delle scritture accidentali sul buffer) e non assicura la scelta delle
+dimensioni ottimali, è sempre meglio lasciare allocare il buffer alle funzioni
+di libreria, che sono in grado di farlo in maniera ottimale e trasparente
+all'utente (in quanto la disallocazione avviene automaticamente). Inoltre
+siccome alcune implementazioni usano parte del buffer per mantenere delle
+informazioni di controllo, non è detto che le dimensioni dello stesso
+coincidano con quelle su cui viene effettuato l'I/O.

 
 \begin{table}[htb]
   \centering
 
 \begin{table}[htb]
   \centering

+  \footnotesize

     \begin{tabular}[c]{|l|l|}
       \hline
       \textbf{Valore} & \textbf{Modalità} \\
     \begin{tabular}[c]{|l|l|}
       \hline
       \textbf{Valore} & \textbf{Modalità} \\


@@ -1409,11 +1437,19 @@ bufferizzata i valori di \param{buf} e \param{size} vengono ignorati.
       \macro{\_IOFBF} & \textit{fully buffered}\\
       \hline
     \end{tabular}
       \macro{\_IOFBF} & \textit{fully buffered}\\
       \hline
     \end{tabular}

+  \caption{Valori del parametro \param{mode} di \func{setvbuf} 
+    per il settaggio delle modalità di bufferizzazione.}

   \label{tab:file_stream_buf_mode}
   \label{tab:file_stream_buf_mode}

-  \caption{Valori possibili per il parametro \param{mode} di \func{setvbuf} 
-    nel settaggio delle modalità di bufferizzazione.}

 \end{table}
 
 \end{table}
 

+Per evitare che \func{setvbuf} setti il 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.  Si potrà comunque
+modificare la modalità di bufferizzazione, passando in \param{mode} uno degli
+opportuni valori elencati in \tabref{tab:file_stream_buf_mode}. Qualora si
+specifichi la modalità non bufferizzata i valori di \param{buf} e \param{size}
+vengono sempre ignorati.
+

 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:
 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:


@@ -1433,11 +1469,10 @@ e \func{setlinebuf}, i loro prototipi sono:
 \end{functions}
 \noindent tutte queste funzioni sono realizzate con opportune chiamate a
 \func{setvbuf} e sono definite solo per compatibilità con le vecchie librerie
 \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:
+BSD. Infine le \acr{glibc} provvedono le funzioni non standard\footnote{anche
+  queste funzioni sono originarie di Solaris.} \func{\_\_flbf} e
+\func{\_\_fbufsize} che permettono di leggere le proprietà di bufferizzazione
+di uno stream; i cui prototipi sono:

 \begin{functions}
   \headdecl{stdio\_ext.h} 
   
 \begin{functions}
   \headdecl{stdio\_ext.h} 
   


@@ -1448,6 +1483,52 @@ stream; dette funzioni sono:
   buffer di \param{stream}.
 \end{functions}
 
   buffer di \param{stream}.
 \end{functions}
 

+Come già accennato, indipendentemente dalla modalità di bufferizzazione
+scelta, si può forzare lo scarico dei dati sul file con la funzione
+\func{fflush}, il suo prototipo è:
+\begin{prototype}{stdio.h}{int fflush(FILE *stream)}
+  
+  Forza la scrittura di tutti i dati bufferizzati dello stream \param{stream}.
+  
+  \bodydesc{Restituisce zero in caso di successo, ed \macro{EOF} in caso di
+    errore, settando \var{errno} a \macro{EBADF} se \param{stream} non è
+    aperto o non è aperto in scrittura, o ad uno degli errori di
+    \func{write}.}
+\end{prototype}
+\noindent anche di questa funzione esiste una analoga
+\func{fflush\_unlocked}\footnote{accessibile definendo \macro{\_BSD\_SOURCE} o
+  \macro{\_SVID\_SOURCE} o \macro{\_GNU\_SOURCE}.} che non effettua il blocco
+dello stream.
+
+Se \param{stream} è \macro{NULL} lo scarico dei dati è forzato per tutti gli
+stream aperti. Esistono però circostanze, ad esempio quando si vuole essere
+sicuri che sia stato eseguito tutto l'output su terminale, in cui serve poter
+effettuare lo scarico dei dati solo per gli stream in modalità line buffered;
+per questo motivo le \acr{glibc} supportano una estensione di Solaris, la
+funzione \func{\_flushlbf}, il cui prototipo è:
+\begin{prototype}{stdio-ext.h}{void \_flushlbf(void)}
+  Forza la scrittura di tutti i dati bufferizzati degli stream in modalità
+  line buffered.
+\end{prototype}
+
+Si ricordi comunque che lo scarico dei dati dai buffer effettuato da queste
+funzioni non comporta la scrittura di questi su disco; se si vuole che il
+kernel dia effettivamente avvio alle operazioni di scrittura su disco occorre
+usare \func{sync} o \func{fsync} (si veda~\secref{sec:file_sync}).
+
+Infine esistono anche circostanze in cui si vuole scartare tutto l'output
+pendente, per questo si può usare \func{fpurge}, il cui prototipo è:
+\begin{prototype}{stdio.h}{int fpurge(FILE *stream)}
+ 
+  Cancella i buffer di input e di output dello stream \param{stream}.
+  
+  \bodydesc{Restituisce zero in caso di successo, ed \macro{EOF} in caso di
+    errore.}
+\end{prototype}
+
+La funzione scarta tutti i dati non ancora scritti (se il file è aperto in
+scrittura), e tutto l'input non ancora letto (se è aperto in lettura),
+compresi gli eventuali caratteri rimandati indietro con \func{ungetc}.

 
 
 \subsection{Gli stream e i thread}
 
 
 \subsection{Gli stream e i thread}


@@ -1490,26 +1571,26 @@ definendo \macro{\_POSIX\_THREAD\_SAFE\_FUNCTIONS} ed i loro prototipi sono:
 \noindent con queste funzioni diventa possibile acquisire un blocco ed
 eseguire tutte le operazioni volute, per poi rilasciarlo. 
 
 \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
+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
 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.
+procedura può comportare dei costi pesanti in termini di prestazioni. Per
+questo motivo abbiamo visto come alle usuali funzioni di I/O non formattato
+siano associate delle versioni \code{\_unlocked} (alcune previste dallo stesso
+standard POSIX, altre aggiunte come estensioni dalle \acr{glibc}) che possono
+essere usate quando il locking non serve\footnote{in certi casi dette funzioni
+  possono essere usate, visto che sono molto più efficienti, anche in caso di
+  necessità di locking, una volta che questo sia stato acquisito manualmente.}
+con prestazioni molto più elevate, dato che spesso queste versioni (come
+accade per \func{getc} e \func{putc}) sono realizzate come macro.

 
 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
 
 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 è:
+abbastanza noioso; per questo motivo le \acr{glibc} provvedono al
+programmatore pigro un'altra via\footnote{anche questa mutuata da estensioni
+  introdotte in Solaris.} da poter utilizzare per disabilitare in blocco il
+locking degli stream: 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
 \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


@@ -1518,7 +1599,10 @@ della funzione \func{\_\_fsetlocking}, il cui prototipo 
   \bodydesc{Restituisce lo stato di locking interno dello stream con uno dei
   valori \macro{FSETLOCKING\_INTERNAL} o \macro{FSETLOCKING\_BYCALLER}.}
 \end{prototype}
   \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:
+
+La funzione setta o legge lo stato della modalità di operazione di uno stream
+nei confronti del locking a seconda del valore specificato con \param{type},
+che può essere uno dei seguenti:

 \begin{basedescript}{\desclabelwidth{4.0cm}}
 \item[\macro{FSETLOCKING\_INTERNAL}] Lo stream userà da ora in poi il blocco
   implicito di default.
 \begin{basedescript}{\desclabelwidth{4.0cm}}
 \item[\macro{FSETLOCKING\_INTERNAL}] Lo stream userà da ora in poi il blocco
   implicito di default.


@@ -1528,3 +1612,8 @@ della funzione \func{\_\_fsetlocking}, il cui prototipo 
   di blocco dello stream.
 \end{basedescript}
 
   di blocco dello stream.
 \end{basedescript}
 

+
+%%% Local Variables: 
+%%% mode: latex
+%%% TeX-master: "gapil"
+%%% End: