X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=filestd.tex;h=df0f1628195187e8754a25e931b3a1a543c591d6;hp=a106ff579ec7a447e9e54f1d40bd345e54bd2c92;hb=7bb9546e0e9ac077f3bb6ef338bd7657dce1aa62;hpb=8adf4f92973a386429c44349c48bfa1812915fb7 diff --git a/filestd.tex b/filestd.tex index a106ff5..df0f162 100644 --- a/filestd.tex +++ b/filestd.tex @@ -1,10 +1,10 @@ - \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. @@ -88,27 +88,27 @@ rappresentano i canali standard di input/output prestabiliti; anche questi tre stream sono identificabili attraverso dei nomi simbolici definiti nell'header \file{stdio.h} che sono: -\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 @@ -228,7 +228,7 @@ prototipi sono: 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}.} @@ -253,6 +253,7 @@ possono essere aperti con le funzioni delle librerie standard del C. \begin{table}[htb] \centering + \footnotesize \begin{tabular}[c]{|l|p{8cm}|} \hline \textbf{Valore} & \textbf{Significato}\\ @@ -275,6 +276,9 @@ possono essere aperti con le funzioni delle librerie standard del C. \texttt{a+} & Il file viene aperto (o creato se non esiste) in \textit{append mode}, l'accesso viene posto in lettura e scrittura. \\ \hline + \texttt{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} @@ -284,7 +288,7 @@ possono essere aperti con le funzioni delle librerie standard del C. 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 @@ -304,13 +308,12 @@ valore \verb|STRING| e \func{fopen} marca il file per l'uso dei caratteri estesi e abilita le opportune funzioni di conversione in lettura e scrittura. -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 @@ -330,7 +333,7 @@ una scrittura una delle funzioni \func{fflush}, \func{fseek}, \func{fsetpos} o \func{rewind} prima di eseguire una rilettura; viceversa nel caso in cui si voglia fare una scrittura subito dopo aver eseguito una lettura occorre prima usare una delle funzioni \func{fseek}, \func{fsetpos} o \func{rewind}. Anche -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 @@ -355,9 +358,9 @@ dati presenti nei buffer in user space usati dalle \acr{glibc}; se si vuole essere sicuri che il kernel forzi la scrittura su disco occorrerà effettuare una \func{sync} (vedi \secref{sec:file_sync}). -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. @@ -396,7 +399,7 @@ notificato come tale dai valori di uscita delle varie funzioni. Nella maggior parte dei casi questo avviene con la restituzione del valore intero (di tipo \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 @@ -437,8 +440,10 @@ la funzione \func{clearerr}, il cui prototipo Cancella i flag di errore ed end-of-file di \param{stream}. \end{prototype} \noindent in genere si usa questa funziona una volta che si sia identificata e -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} @@ -489,10 +494,10 @@ si avr 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"); @@ -504,7 +509,7 @@ in cui si specifica la dimensione dell'intera struttura ed un solo 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. @@ -546,10 +551,9 @@ rileggere i dati tenendo conto delle eventuali differenze. Le \acr{glibc} definiscono altre due funzioni per l'I/O binario, che evitano il lock implicito dello stream, usato per dalla librerie per la gestione delle applicazioni multi-thread (si veda -\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)} @@ -580,7 +584,7 @@ rispettivi prototipi sono: \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 @@ -589,14 +593,14 @@ rispettivi prototipi sono: A parte \func{getchar}, che si usa in genere per leggere un carattere da tastiera, le altre due funzioni sono sostanzialmente equivalenti. La -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 @@ -621,7 +625,7 @@ byte restituiscono un carattere in formato esteso (cio \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}.} @@ -639,7 +643,7 @@ precedenti usate per leggere: \func{putc}, \func{fputc} e \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 @@ -654,7 +658,7 @@ sempre un intero; in caso di errore o fine del file il valore di ritorno 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. @@ -745,13 +749,13 @@ prototipi sono: 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 @@ -794,13 +798,13 @@ rispettivi prototipi sono: 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: @@ -825,7 +829,7 @@ anzich 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}). @@ -908,25 +912,24 @@ chiama \func{getdelim} ed il suo prototipo 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 @@ -940,13 +943,14 @@ famiglia \func{printf}; le tre pi \bodydesc{Le funzioni ritornano il numero di caratteri stampati.} \end{functions} \noindent le prime due servono per stampare su file (lo standard output -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}; 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} @@ -961,6 +965,7 @@ 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} \\ @@ -1002,68 +1007,218 @@ degli specificatori di conversione (riportati in \ntab) che la conclude. \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 +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 i valori opzionali sono indicati fra parentesi, e prevedono la -presenza, in questo ordine, di: uno specificatore per il parametro da usare -(terminato da un \cmd{\$}, uno o più flag (riassunti in -\tabref{tab:file_format_flag}) che controllano il formato di stampa della -conversione (riassunti in \tabref{tab:file_format_type}), uno specificatore di -larghezza, eventualmente seguito (per i numeri in virgola mobile) da un -specificatore di precisione, uno specificatore del tipo di dato (che ne indica -la lunghezza). +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{\#} & \\ - \cmd{0} & \\ - \cmd{-} & \\ - \cmd{' '} & \\ - \cmd{+} & \\ + \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} & \\ - \cmd{h} & \\ - \cmd{l} & \\ - \cmd{ll} & \\ - \cmd{L} & \\ - \cmd{q} & \\ - \cmd{j} & \\ - \cmd{z} & \\ - \cmd{t} & \\ + \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} @@ -1075,14 +1230,14 @@ 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 -un numero di caratteri (ad esempio in VMS può essere rappresentata come -numero di record, e offset rispetto al record corrente). +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 @@ -1099,64 +1254,106 @@ 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 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. @@ -1181,8 +1378,153 @@ del buffer e del suo contenuto. \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} @@ -1194,8 +1536,19 @@ consapevoli delle possibili complicazioni anche quando non si usano i 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} @@ -1211,16 +1564,52 @@ pesantemente dalle richieste necessarie per garantirne l'uso coi thread. \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: