- \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,
-quella che viene comunemente detta interfaccia degli \textit{stream}.
-Dopo una breve sezione introduttiva tratteremo le funzioni base per la
-gestione dell'input/output, mentre tratteremo le caratteristiche più avanzate
+quella che viene comunemente detta interfaccia degli \textit{stream}. Dopo
+una breve sezione introduttiva tratteremo le funzioni base per la gestione
+dell'input/output, mentre tratteremo le caratteristiche più avanzate
dell'interfaccia nell'ultima sezione.
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.
-\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.
-\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.
-\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]{}
- 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
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}.}
\begin{table}[htb]
\centering
+ \footnotesize
\begin{tabular}[c]{|l|p{8cm}|}
\hline
\textbf{Valore} & \textbf{Significato}\\
\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}
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
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
\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
-(vedi \secref{sec:file_buffering_ctrl}) fintanto che non si è effettuato
+(si veda \secref{sec:file_buffering_ctrl}) fintanto che non si è effettuato
alcuna operazione di I/O sul file.
Uno stream viene chiuso con la funzione \func{fclose} il cui prototipo è:
\func{fflush}).}
\end{prototype}
-La funzione effettua uno scarico di tutti i dati presenti nei buffer di
-uscita e scarta tutti i dati in ingresso, se era stato allocato un
-buffer per lo stream questo verrà rilasciato. La funzione effettua lo
-scarico solo per i 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}.
+La funzione effettua lo scarico di tutti i dati presenti nei buffer di uscita
+e scarta tutti i dati in ingresso; se era stato allocato un buffer per lo
+stream questo verrà rilasciato. La funzione effettua lo scarico solo per i
+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.
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
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}
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");
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.
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)}
\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
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
\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}.}
\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
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.
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
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:
\begin{functions}
- \headdecl{whar.h}
+ \headdecl{wchar.h}
\funcdecl{wchar\_t *fgetws(wchar\_t *ws, int n, FILE *stream)}
Legge un massimo di \param{n} caratteri estesi dal file
\param{stream} al buffer \param{ws}.
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}).
\func{fgets} non abbia i gravissimi problemi di \func{gets}, può
comunque dare risultati ambigui se l'input contiene degli zeri; questi
infatti saranno scritti sul buffer di uscita e la stringa in output
-apparirà come più corta dei bytes effettivamente letti. Questa è una
+apparirà come più corta dei byte effettivamente letti. Questa è una
condizione che è sempre possibile controllare (deve essere presente un
newline prima della effettiva conclusione della stringa presente nel
buffer), ma a costo di una complicazione ulteriore della logica del
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
\bodydesc{Le funzioni ritornano il numero di caratteri stampati.}
\end{functions}
\noindent le prime due servono per stampare su file (lo standard output
-o quallo 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}; per questo motivo si
-consiglia l'uso dell'alternativa:
+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 variabili e
+possibili buffer overflow; per questo motivo si consiglia l'uso
+dell'alternativa:
\begin{prototype}{stdio.h}
-{snprintf(char *str, size\_t size, const char *format, ...);}
+{snprintf(char *str, size\_t size, const char *format, ...)}
Identica a \func{sprintf}, ma non scrive su \param{str} più di
\param{size} caratteri.
\end{prototype}
-La parte più complessa di queste funzioni è il formato della variabile
-\param{format} che indica le conversioni da fare ed il numero di
-parametri che dovranno essere specificati a seguire.
+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.
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|l|p{10cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Tipo} & \textbf{Significato} \\
+ \hline
+ \hline
+ \cmd{\%d} &\type{int} & Stampa un numero intero in formato decimale
+ con segno \\
+ \cmd{\%i} &\type{int} & Identico a \cmd{\%i} in output, \\
+ \cmd{\%o} &\type{unsigned int}& Stampa un numero intero come ottale\\
+ \cmd{\%u} &\type{unsigned int}& Stampa un numero intero in formato
+ decimale senza segno \\
+ \cmd{\%x},
+ \cmd{\%X} &\type{unsigned int}& Stampano un intero in formato esadecimale,
+ rispettivamente con lettere minuscole e
+ maiuscole. \\
+ \cmd{\%f} &\type{unsigned int}& Stampa un numero in virgola mobile con la
+ notazione a virgola fissa \\
+ \cmd{\%e},
+ \cmd{\%E} &\type{double} & Stampano un numero in virgola mobile con la
+ notazione esponenziale, rispettivamente con
+ lettere minuscole e maiuscole. \\
+ \cmd{\%g},
+ \cmd{\%G} &\type{double} & Stampano un numero in virgola mobile con la
+ notazione più appropriate delle due precedenti,
+ rispettivamente con lettere minuscole e
+ maiuscole. \\
+ \cmd{\%a},
+ \cmd{\%A} &\type{double} & Stampano un numero in virgola mobile in
+ notazione esadecimale frazionaria\\
+ \cmd{\%c} &\type{int} & Stampa un carattere singolo\\
+ \cmd{\%s} &\type{char *} & Stampa una stringa \\
+ \cmd{\%p} &\type{void *} & Stampa il valore di un puntatore\\
+ \cmd{\%n} &\type{\&int} & Prende il numero di caratteri stampati finora\\
+ \cmd{\%\%}& & Stampa un \% \\
+ \hline
+ \end{tabular}
+ \caption{Valori possibili per gli specificatori di conversione in una
+ stringa di formato di \func{printf}.}
+ \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
+generale essa è sempre del tipo:
+\begin{center}
+\begin{verbatim}
+% [n. parametro $] [flag] [[larghezza] [. precisione]] [tipo] conversione
+\end{verbatim}
+\end{center}
+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
+ \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}
+
+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} \\
+ \hline
+ \hline
+ \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 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 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 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
+ \type{double}.\\
+ \cmd{q} & sinonimo di \cmd{ll}.\\
+ \cmd{j} & una conversione intera corrisponde a un \type{intmax\_t} o
+ \type{uintmax\_t}.\\
+ \cmd{z} & una conversione intera corrisponde a un \type{size\_t} o
+ \type{ssize\_t}.\\
+ \cmd{t} & una conversione intera corrisponde a un \type{ptrdiff\_t}.\\
+ \hline
+ \end{tabular}
+ \caption{Il modificatore di tipo di dato per il formato di \func{printf}}
+ \label{tab:file_format_type}
+\end{table}
+Una versione alternativa delle funzioni di output formattato, che permettono
+di usare il puntatore ad una lista di argomenti (vedi
+\secref{sec:proc_variadic}), sono le seguenti:
+\begin{functions}
+ \headdecl{stdio.h}
+
+ \funcdecl{int vprintf(const char *format, va\_list ap)} Stampa su
+ \var{stdout} gli argomenti della lista \param{ap}, secondo il formato
+ specificato da \param{format}.
+
+ \funcdecl{int vfprintf(FILE *stream, const char *format, va\_list ap)}
+ Stampa su \param{stream} gli argomenti della lista \param{ap}, secondo il
+ formato specificato da \param{format}.
+
+ \funcdecl{int vsprintf(char *str, const char *format, va\_list ap)} Stampa
+ sulla stringa \param{str} gli argomenti della lista \param{ap}, secondo il
+ formato specificato da \param{format}.
+ \bodydesc{Le funzioni ritornano il numero di caratteri stampati.}
+\end{functions}
+\noindent con queste funzioni diventa possibile selezionare gli argomenti che
+si vogliono passare ad una routine di stampa, passando direttamente la lista
+tramite il parametro \param{ap}. Per poter far questo ovviamente la lista dei
+parametri dovrà essere opportunamente trattata (l'argomento è esaminato in
+\secref{sec:proc_variadic}), e dopo l'esecuzione della funzione l'argomento
+\param{ap} non sarà più utilizzabile (in generale dovrebbe essere eseguito un
+\macro{va\_end(ap)} ma in Linux questo non è necessario).
+
+Come per \func{sprintf} anche per \func{vsprintf} esiste una analoga
+\func{vsnprintf} che pone un limite sul numero di caratteri che vengono
+scritti sulla stringa di destinazione:
+\begin{prototype}{stdio.h}
+{vsnprintf(char *str, size\_t size, const char *format, va\_list ap)}
+ 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 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}
\label{sec:file_fseek}
Come per i file descriptor è possibile anche con gli stream spostarsi
-all'interno di un file per effettuare operazioni di lettura o scrittura
-in un punto prestabilito; questo fintanto che l'operazione di
-riposizionamento è supportata dal file sottostante lo stream, quando
-cioè si ha a che fare con quelio 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).
-
-Tutto questo comporta la presenza di diverse funzioni che seguono
+all'interno di un file per effettuare operazioni di lettura o scrittura in un
+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 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
diverso. Le funzioni tradizionali usate per il riposizionamento della
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 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}
\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)}
+ \funcdecl{int \_\_freadable(FILE *stream)}
Restituisce un valore diverso da zero se \param{stream} consente la lettura.
\funcdecl{int \_\_fwritable(FILE *stream)}
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 è:
\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.
\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 \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 librerie, 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 le dimensioni con cui viene effettuato l'I/O.
+
+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 \ntab. Qualora si specifichi la modalità non
+bufferizzata i valori di \param{buf} e \param{size} vengono sempre ignorati.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \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. Infine le \acr{glibc} provvedono le funzioni non standard\footnote{anche
+ queste 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}
+
+ \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}
+
+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}
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}
\funcdecl{void funlockfile(FILE *stream)} Rilascia il lock dello
stream \param{stream}.
\end{functions}
+\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 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
+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
+ 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}
-\subsection{Dettagli dell'implementazione}
-\label{sec:file_stream_details}
-
-
-\subsection{File temporanei}
-\label{sec:file_temp_file}
-
-
-\subsection{Efficienza}
-\label{sec:file_stream_efficiency}
-
+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.
+\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}
+
+
+%%% Local Variables:
+%%% mode: latex
+%%% TeX-master: "gapil"
+%%% End:
projects / gapil.git / blobdiff