X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=filestd.tex;h=79931fc4a59b10e8ab60bf96df807c89098f30fe;hp=13934c3ef8c8887751059e80306031caa8be86b4;hb=89ab23ea8770a3b4c7a617acf1aae071ce87c8f1;hpb=cdc1b275bbd83ad0dbf1ba4be801118724a51085 diff --git a/filestd.tex b/filestd.tex index 13934c3..79931fc 100644 --- a/filestd.tex +++ b/filestd.tex @@ -107,8 +107,8 @@ 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 @@ -304,13 +304,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 @@ -355,9 +354,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. @@ -437,8 +436,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 +490,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"); @@ -546,10 +547,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)} @@ -589,14 +589,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 @@ -745,13 +745,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 +794,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: @@ -942,7 +942,7 @@ L'output formattato viene eseguito con una delle 13 funzioni della famiglia 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} @@ -1010,7 +1010,7 @@ generale essa % [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: @@ -1056,17 +1056,17 @@ di \func{printf} e nella documentazione delle \acr{glibc}. \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 @@ -1144,7 +1144,7 @@ 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 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. @@ -1207,7 +1207,7 @@ 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 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 @@ -1252,7 +1252,7 @@ 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'inzio dello stream, ma non esattamente equivalente ad +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. @@ -1298,24 +1298,39 @@ argomenti di tipo \type{off\_t} anzich In questa sezione esamineremo alcune funzioni avanzate che permettono di eseguire operazioni particolari sugli stream, come leggerne gli attributi, -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)} @@ -1325,6 +1340,7 @@ stream; questo pu 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 è: @@ -1382,20 +1398,28 @@ sistema passandone alla funzione l'indirizzo in \param{buf} e la dimensione in Ovviamente se si usa un buffer specificato dall'utente questo deve essere stato allocato e restare disponibile per tutto il tempo in cui si opera sullo stream. In genere conviene allocarlo con \func{malloc} e disallocarlo dopo la -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 @@ -1410,8 +1434,8 @@ bufferizzata i valori di \param{buf} e \param{size} vengono ignorati. \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 @@ -1433,11 +1457,10 @@ e \func{setlinebuf}, i loro prototipi sono: \end{functions} \noindent tutte queste funzioni sono realizzate con opportune chiamate a \func{setvbuf} e sono definite solo per compatibilità con le vecchie librerie -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} @@ -1448,6 +1471,52 @@ stream; dette funzioni sono: 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} @@ -1490,26 +1559,26 @@ definendo \macro{\_POSIX\_THREAD\_SAFE\_FUNCTIONS} ed i loro prototipi sono: \noindent con queste funzioni diventa possibile acquisire un blocco ed eseguire tutte le operazioni volute, per poi rilasciarlo. -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 \code{\_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 +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, e che appesantisce il codice; per questo motivo le -\acr{glibc} provvedono un'altra via per poter utilizzare disabilitare il -locking, anch'essa mutuata da estensioni introdotte in Solaris, cioè l'uso -della funzione \func{\_\_fsetlocking}, il cui prototipo è: +abbastanza noioso; per questo motivo le \acr{glibc} provvedono al +programmatore pigro un'altra via\footnote{anche questa mutuata da estensioni + introdotte in Solaris.} da poter utilizzare per disabilitare in blocco il +locking degli stream: l'uso della funzione \func{\_\_fsetlocking}, il cui +prototipo è: \begin{prototype}{stdio\_ext.h}{int \_\_fsetlocking (FILE *stream, int type)} Specifica o richiede a seconda del valore di \param{type} la modalità in cui le operazioni di I/O su \param{stream} vengono effettuate rispetto @@ -1518,7 +1587,10 @@ della funzione \func{\_\_fsetlocking}, il cui prototipo \bodydesc{Restituisce lo stato di locking interno dello stream con uno dei valori \macro{FSETLOCKING\_INTERNAL} o \macro{FSETLOCKING\_BYCALLER}.} \end{prototype} -\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. @@ -1528,3 +1600,8 @@ della funzione \func{\_\_fsetlocking}, il cui prototipo di blocco dello stream. \end{basedescript} + +%%% Local Variables: +%%% mode: latex +%%% TeX-master: "gapil" +%%% End: