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
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:
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}).
o quello specificato) la terza permette di stampare su una stringa, in genere
l'uso di \func{sprintf} è sconsigliato in quanto è possibile, se non si ha la
sicurezza assoluta sulle dimensioni del risultato della stampa, eccedere le
-dimensioni di \param{str} con conseguente sovrascrittura di altre varibili e
+dimensioni di \param{str} con conseguente sovrascrittura di altre variabili e
possibili buffer overflow; per questo motivo si consiglia l'uso
dell'alternativa:
\begin{prototype}{stdio.h}
\begin{table}[htb]
\centering
+ \footnotesize
\begin{tabular}[c]{|l|l|p{10cm}|}
\hline
\textbf{Valore} & \textbf{Tipo} & \textbf{Significato} \\
% [n. parametro $] [flag] [[larghezza] [. precisione]] [tipo] conversione
\end{verbatim}
\end{center}
-in cui tutti i valori tranne il \cmd{\%} e lo specificatatore di conversione
+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{table}[htb]
\centering
+ \footnotesize
\begin{tabular}[c]{|l|p{10cm}|}
\hline
\textbf{Valore} & \textbf{Significato}\\
\begin{table}[htb]
\centering
+ \footnotesize
\begin{tabular}[c]{|l|p{10cm}|}
\hline
\textbf{Valore} & \textbf{Significato} \\
\hline
\hline
- \cmd{hh} & una conversione intera corriponde a un \type{char} con o senza
+ \cmd{hh} & una conversione intera corrisponde a un \type{char} con o senza
segno, o il puntatore per il numero dei parametri \cmd{n} è di
tipo \type{char}.\\
- \cmd{h} & una conversione intera corriponde a uno \type{short} con o
+ \cmd{h} & una conversione intera corrisponde a uno \type{short} con o
senza segno, o il puntatore per il numero dei parametri \cmd{n}
è di tipo \type{short}.\\
- \cmd{l} & una conversione intera corriponde a un \type{long} con o
+ \cmd{l} & una conversione intera corrisponde a un \type{long} con o
senza segno, o il puntatore per il numero dei parametri \cmd{n}
è di tipo \type{long}, o il carattere o la stringa seguenti
sono in formato esteso.\\
- \cmd{ll} & una conversione intera corriponde a un \type{long long} con o
+ \cmd{ll} & una conversione intera corrisponde a un \type{long long} con o
senza segno, o il puntatore per il numero dei parametri \cmd{n}
è di tipo \type{long long}.\\
\cmd{L} & una conversione in virgola mobile corrisponde a un
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 onoltre ricordarsi di
+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 \func{w}
-davanti a \func{print}, sono trattate in dettaglio nella documentazione delle
+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
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 effetture
+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
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'inzio dello stream, ma non esattamente equivalente ad
-una \func{fseek(stream, 0L, SEEK\_SET)} in quanto vengono cancellati anche i
+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 ottenere la posizione corrente si usa invece la funzione \func{ftell}, il
\headdecl{stdio.h}
\funcdecl{int fsetpos(FILE *stream, fpos\_t *pos)} Setta la posizione
- corrente nello stream \param{stream} al valore specificato da \func{pos}.
+ 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 \func{pos}.
+ corrente nello stream \param{stream} in \param{pos}.
\bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
errore.}
In questa sezione esamineremo alcune funzioni avanzate che permettono di
eseguire operazioni particolari sugli stream, come leggerne gli attributi,
-controllarne le modalità di bufferizzazione, ecc.
+controllarne le modalità di bufferizzazione, gestire direttamente i lock
+impliciti per la programmazione multi thread.
\subsection{Le funzioni di controllo}
\label{sec:file_stream_cntrl}
Al contrario di quanto avviene con i file descriptor le librerie standard del
-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)}
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{prototype}{stdio.h}{int setvbuf(FILE *stream, char *buf, int mode,
size\_t size)}
- Setta la bufferizzazione dello stream \func{stream} nella modalità indicata
- da \param{mode}, usando \func{buf} come buffer di lunghezza \param{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.}
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
-\func{size}.
+\param{size}.
Ovviamente se si usa un buffer specificato dall'utente questo deve essere
stato allocato e restare disponibile per tutto il tempo in cui si opera sullo
stream. In genere conviene allocarlo con \func{malloc} e disallocarlo dopo la
-chiusura del file, ma fintanto che il file è usato all'interno di una
-funzione, può anche essere usata una variabile automatica; in genere è
-definita una macro \macro{BUFSIZ} che indica le dimensioni ottimali del
-buffer. Dato che la procedura è macchinosa e comporta dei rischi (come delle
-scritture accidentali sul buffer) è sempre meglio lasciare allocare il buffer
-alle funzioni di librerie, che sono in grado di farlo in maniera ottimale e
-trasparente all'utente.
-
-Per evitare il settaggio del buffer basta passare un valore \macro{NULL} per
-\param{buf} e la funzione ignorerà il parametro \param{size} usando il buffer
-allocato automaticamente dal sistema. In questo modo si potrà comunque
+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 specifiche la modalità non
-bufferizzata i valori di \param{buf} e \param{size} vengono ignorati.
+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
\end{tabular}
\label{tab:file_stream_buf_mode}
- \caption{Valori possibili per il parametro \param{mode} di \func{setvbuf}
- nel settaggio delle modalità di bufferizzazione.}
+ \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
\headdecl{stdio.h}
\funcdecl{void setbuf(FILE *stream, char *buf)} Disabilita la
- bufferizzazione se \param{buf} è \macro{NULL}, altrimenti usa \func{buf}
+ 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 \func{buf}
+ 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à
\end{functions}
\noindent tutte queste funzioni sono realizzate con opportune chiamate a
\func{setvbuf} e sono definite solo per compatibilità con le vecchie librerie
-BSD.
-
-Sempre seguendo Solaris le \acr{glibc} provvedono alcune estensioni non
-standard che permettono di leggere le proprietà di bufferizzazione di uno
-stream; dette funzioni sono:
+BSD. Infine le \acr{glibc} provvedono le funzioni non standard\footnote{anche
+ queste 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}
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}
\noindent con queste funzioni diventa possibile acquisire un blocco ed
eseguire tutte le operazioni volute, per poi rilasciarlo.
-Ma vista la complessità delle strutture di dati coinvolte, le operazioni di
+Ma, vista la complessità delle strutture di dati coinvolte, le operazioni di
blocco non sono del tutto indolori, e quando il locking dello stream non è
necessario (come in tutti i programmi che non usano i thread), tutta la
-procedura può comportare dei pesanti costi in termini di prestazioni. Per
-questo motivo abbiamo visto in come per tutte le funzioni di I/O non
-formattato esistano delle versioni \func{\_unlocked} (alcune previste dallo
-standard POSIX stesso, altre aggiunte come estenzioni dalle \acr{glibc}) che
-possono essere usate in tutti questi casi\footnote{in certi casi dette
- funzioni possono essere usate, visto che sono molto più efficiente, anche in
- caso di necessità di locking, una volta che questo sia stato acquisito
- manualmente.} dato che in molti casi (come per esempio \func{getc} e
-\func{putc}) queste versioni possono essere realizzate come macro, e sono
-pertanto in grado di garantire prestazione enormemente più elevate.
-
-La sostituizione di tutte le funzioni di I/O con le relative versioni
-\func{\_unlocked} in un programma che non usa i thread è però un lavoro
-abbastanza noioso, e che appesantisce il codice; per questo motivo le
-\acr{glibc} provvedono un'altra via per poter utilizzare disabilitare il
-locking, anch'essa mutuata da estensioni introdotte in Solaris, cioè l'uso
-della funzione \func{\_\_fsetlocking}, il cui prototipo è:
+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
\bodydesc{Restituisce lo stato di locking interno dello stream con uno dei
valori \macro{FSETLOCKING\_INTERNAL} o \macro{FSETLOCKING\_BYCALLER}.}
\end{prototype}
-\noindent ed i valori possibili per \param{type} sono i seguenti:
+
+La funzione setta o legge lo stato della modalità di operazione di uno stream
+nei confronti del locking a seconda del valore specificato con \param{type},
+che può essere uno dei seguenti:
\begin{basedescript}{\desclabelwidth{4.0cm}}
\item[\macro{FSETLOCKING\_INTERNAL}] Lo stream userà da ora in poi il blocco
implicito di default.
\end{basedescript}
-\subsection{File temporanei}
-\label{sec:file_temp_file}
-
-Un'altra serie di funzioni definite dalle librerie standard del C sono quelle
-che riguardano la creazione di file temporanei.
+%%% Local Variables:
+%%% mode: latex
+%%% TeX-master: "gapil"
+%%% End:
projects / gapil.git / blobdiff