- \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.
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}.}
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}
\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, il cui formato è sempre
-del tipo:
+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
+ \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
+% [n. parametro $] [flag] [[larghezza] [. precisione]] [tipo] conversione
\end{verbatim}
\end{center}
-in cui devono essere sempre presenti il carattere \texttt{\%}, che introduce
-la direttiva, ed uno degli specificatori di conversione (riportatati in \ntab)
-che la conclude; gli altri valori, indicati fra parentesi, sono opzionali.
+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
\begin{tabular}[c]{|l|p{10cm}|}
\hline
- \textbf{Valore} & \textbf{Significato} \\
+ \textbf{Valore} & \textbf{Significato}\\
\hline
\hline
- \cmd{\%d} & Stampa un numero intero in formato decimale
- con segno\\
- \cmd{\%i} & Identico a \cmd{\%i} in output, \\
- \cmd{\%o} & Stampa un numero intero come ottale\\
- \cmd{\%u} & Stampa un numero intero in formato decimale senza
- segno \\
- \cmd{\%x}, \cmd{\%X} & Stampano un intero in formato esadecimale,
- rispettivamente con lettere minuscole e maiuscole. \\
- \cmd{\%f} & Stampa un numero in virgola mobile con la notazione
- a virgola fissa \\
- \cmd{\%e}, \cmd{\%E} & Stampano un numero in virgola mobile con la notazione
- esponenziale, rispettivamente con lettere minuscole
- e maiuscole. \\
- \cmd{\%g}, \cmd{\%G} & Stampano un numero in virgola mobile con la notazione
- più appropriate delle due precedenti,
- rispettivamente con lettere minuscole e maiuscole. \\
- \cmd{\%a}, \cmd{\%A} & Stampano un numero in virgola mobile in notazione
- esadecimale frazionaria\\
- \cmd{\%c} & Stampa un carattere singolo\\
- \cmd{\%s} & Stampa una stringa \\
- \cmd{\%p} & Stampa il valore di un puntatore\\
- \cmd{\%n} & Prende il numero di caratteri stampati finora\\
+ \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{Valori possibili per gli specificatori di conversione in una
- stringa di formato per l'output.}
- \label{tab:file_format_spec}
+ \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
+ \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).
+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
all'inizio del file.
\end{functions}
-L'uso di \func{fseek} è del tutto analogo a quello di \func{lseek} per i
-file descriptor, ed i parametri, a parte il tipo, hanno lo stesso
-significato; in particolare \param{whence} assume gli stessi valori già
-visti in \secref{sec:file_lseek}. La funzione restituisce 0 in caso di
-successo e -1 in caso di errore.
+L'uso di \func{fseek} è del tutto analogo a quello di \func{lseek} per i file
+descriptor, ed i parametri, a parte il tipo, hanno lo stesso significato; in
+particolare \param{whence} assume gli stessi valori già visti in
+\secref{sec:file_lseek}. La funzione restituisce 0 in caso di successo e -1
+in caso di errore. La funzione \func{rewind} riporta semplicemente la
+posizione corrente all'inizio dello stream, ma non esattamente equivalente ad
+una \code{fseek(stream, 0L, SEEK\_SET)} in quanto vengono cancellati anche i
+flag di errore e fine del file.
-Per leggere la posizione corrente si usa invece la funzione \func{ftell}, il
+Per ottenere la posizione corrente si usa invece la funzione \func{ftell}, il
cui prototipo è:
\begin{prototype}{stdio.h}{long ftell(FILE *stream)}
- Legge la posizione attuale nello stream.
+ Legge la posizione attuale nello stream \param{stream}.
\bodydesc{La funzione restituisce la posizione corrente, o -1 in caso
di fallimento, che può esser dovuto sia al fatto che il file non
supporta il riposizionamento che al fatto che la posizione non può
essere espressa con un \type{long int}}
\end{prototype}
-
+\noindent la funzione restituisce la posizione come numero di byte
+dall'inizio dello stream.
+
+Queste funzioni esprimono tutte la posizione nel file come un \func{long int},
+dato che (ad esempio quando si usa un filesystem indicizzato a 64 bit) questo
+può non essere possibile lo standard POSIX ha introdotto le nuove funzioni
+\func{fgetpos} e \func{fsetpos}, che invece usano il nuovo tipo
+\type{fpos\_t}, ed i cui prototipi sono:
+\begin{functions}
+ \headdecl{stdio.h}
+
+ \funcdecl{int fsetpos(FILE *stream, fpos\_t *pos)} Setta la posizione
+ corrente nello stream \param{stream} al valore specificato da \param{pos}.
+ \funcdecl{int fgetpos(FILE *stream, fpos\_t *pos)} Scrive la posizione
+ corrente nello stream \param{stream} in \param{pos}.
+
+ \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
+ errore.}
+\end{functions}
+
+In Linux, a partire dalle glibc 2.1, sono presenti anche le funzioni
+\func{fseeko} e \func{ftello}, assolutamente identiche alle precedenti ma con
+argomenti di tipo \type{off\_t} anziché di tipo \type{long int}.
+
\section{Funzioni avanzate}
\label{sec:file_stream_adv_func}
-In questa sezione esamineremo le funzioni che permettono di controllare
-alcune caratteristiche più particolari degli stream, come la lettura
-degli attributi, le modalità di bufferizzazione, etc.
+In questa sezione esamineremo alcune funzioni avanzate che permettono di
+eseguire operazioni particolari sugli stream, come leggerne gli attributi,
+controllarne le modalità di bufferizzazione, gestire direttamente i lock
+impliciti per la programmazione multi thread.
\subsection{Le funzioni di controllo}
\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
+ \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