+
+Dettagli ulteriori sulle varie opzioni possono essere trovati nella pagina di
+manuale di \func{printf} e nella documentazione delle \acr{glibc}.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|p{10cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Significato} \\
+ \hline
+ \hline
+ \cmd{hh} & Una conversione intera corrisponde a un \ctyp{char} con o senza
+ segno, o il puntatore per il numero dei parametri \cmd{n} è di
+ tipo \ctyp{char}.\\
+ \cmd{h} & Una conversione intera corrisponde a uno \ctyp{short} con o
+ senza segno, o il puntatore per il numero dei parametri \cmd{n}
+ è di tipo \ctyp{short}.\\
+ \cmd{l} & Una conversione intera corrisponde a un \ctyp{long} con o
+ senza segno, o il puntatore per il numero dei parametri \cmd{n}
+ è di tipo \ctyp{long}, o il carattere o la stringa seguenti
+ sono in formato esteso.\\
+ \cmd{ll} & Una conversione intera corrisponde a un \ctyp{long long} con o
+ senza segno, o il puntatore per il numero dei parametri \cmd{n}
+ è di tipo \ctyp{long long}.\\
+ \cmd{L} & Una conversione in virgola mobile corrisponde a un
+ \ctyp{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 variabile \index{funzioni!variadic} di
+argomenti (vedi sez.~\ref{sec:proc_variadic}), sono \funcd{vprintf},
+\funcd{vfprintf} e \funcd{vsprintf}, i cui prototipi sono:
+\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 funzione di stampa, passando direttamente la lista
+tramite l'argomento \param{ap}. Per poter far questo ovviamente la lista
+variabile\index{funzioni!variadic} degli argomenti dovrà essere opportunamente
+trattata (l'argomento è esaminato in sez.~\ref{sec:proc_variadic}), e dopo
+l'esecuzione della funzione l'argomento
+\param{ap} non sarà più utilizzabile (in generale dovrebbe essere eseguito un
+\code{va\_end(ap)} ma in Linux questo non è necessario).
+
+Come per \func{sprintf} anche per \func{vsprintf} esiste una analoga
+\funcd{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 \itindex{buffer~overflow} buffer
+overflow.
+
+
+Per eliminare alla radice questi problemi, le \acr{glibc} supportano una
+specifica estensione GNU che alloca dinamicamente tutto lo spazio necessario;
+l'estensione si attiva al solito definendo \macro{\_GNU\_SOURCE}, le due
+funzioni sono \funcd{asprintf} e \funcd{vasprintf}, ed i rispettivi prototipi
+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 argomento \param{strptr} che deve essere
+l'indirizzo di un puntatore ad una stringa di caratteri, in cui verrà
+restituito (si ricordi quanto detto in sez.~\ref{sec:proc_var_passing} a
+proposito dei \itindex{value~result~argument} \textit{value result argument})
+l'indirizzo della stringa allocata automaticamente dalle funzioni. Occorre
+inoltre ricordarsi di invocare \func{free} per liberare detto puntatore quando
+la stringa non serve più, onde evitare \itindex{memory~leak} \textit{memory
+ leak}.
+
+% TODO verificare se mettere prototipi di \func{dprintf} e \func{vdprintf}
+
+Infine una ulteriore estensione GNU definisce le due funzioni \funcm{dprintf} e
+\funcm{vdprintf}, che prendono un file descriptor al posto dello
+\textit{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 \funcd{scanf},
+\funcd{fscanf} e \funcd{sscanf}, i cui prototipi 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 negli argomenti 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 \val{EOF}.}
+\end{functions}
+\noindent e come per le analoghe funzioni di scrittura esistono le relative
+\funcm{vscanf}, \funcm{vfscanf} e \funcm{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 \textit{stream} (o dalla stringa) di
+input ed eseguono un confronto con quanto indicato in \param{format}, la
+sintassi di questo argomento è 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 ecc.), 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 pagine di manuale 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
+\textit{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 \cmd{flex}\footnote{il programma
+ \cmd{flex}, è una implementazione libera di \cmd{lex} un generatore di
+ analizzatori lessicali. Per i dettagli si può fare riferimento al manuale
+ \cite{flex}.} per generare un analizzatore lessicale o il
+\cmd{bison}\footnote{il programma \cmd{bison} è un clone del generatore di
+ parser \cmd{yacc}, maggiori dettagli possono essere trovati nel relativo
+ manuale \cite{bison}.} per generare un parser.
+
+
+\subsection{Posizionamento su uno \textit{stream}}
+\label{sec:file_fseek}
+
+Come per i file descriptor anche per gli \textit{stream} è possibile spostarsi
+all'interno di un file per effettuare operazioni di lettura o scrittura in un
+punto prestabilito; sempre che l'operazione di riposizionamento sia supportata
+dal file sottostante lo \textit{stream}, quando cioè si ha a che fare con
+quello che viene detto un file ad \textsl{accesso casuale}.\footnote{dato che
+ in un sistema Unix esistono vari tipi di file, come le fifo ed i
+ \index{file!di~dispositivo} file di dispositivo, non è scontato che questo
+ sia sempre vero.}
+
+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 è che alcune delle funzioni usate per il riposizionamento sugli
+\textit{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, più
+l'offset rispetto al record corrente).
+
+Tutto questo comporta la presenza di diverse funzioni che eseguono
+sostanzialmente le stesse operazioni, ma usano argomenti di tipo diverso. Le
+funzioni tradizionali usate per il riposizionamento della posizione in uno
+\textit{stream} sono \funcd{fseek} e \funcd{rewind} i cui prototipi sono:
+\begin{functions}
+ \headdecl{stdio.h}
+
+ \funcdecl{int fseek(FILE *stream, long offset, int whence)} Sposta la
+ posizione nello \textit{stream} secondo quanto specificato
+ tramite \param{offset} e \param{whence}.
+
+ \funcdecl{void rewind(FILE *stream)} Riporta la posizione nello
+ \textit{stream} all'inizio del file.
+\end{functions}
+
+L'uso di \func{fseek} è del tutto analogo a quello di \func{lseek} per i file
+descriptor, e gli argomenti, a parte il tipo, hanno lo stesso significato; in
+particolare \param{whence} assume gli stessi valori già visti in
+sez.~\ref{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 \textit{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 \funcd{ftell}, il
+cui prototipo è:
+\begin{prototype}{stdio.h}{long ftell(FILE *stream)}
+ Legge la posizione attuale nello \textit{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 \ctyp{long int}}
+\end{prototype}
+\noindent la funzione restituisce la posizione come numero di byte
+dall'inizio dello \textit{stream}.
+
+Queste funzioni esprimono tutte la posizione nel file come un \ctyp{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
+\funcd{fgetpos} e \funcd{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)} Imposta la posizione
+ corrente nello \textit{stream} \param{stream} al valore specificato
+ da \param{pos}.
+
+ \funcdecl{int fgetpos(FILE *stream, fpos\_t *pos)} Legge la posizione
+ corrente nello \textit{stream} \param{stream} e la scrive 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 due funzioni
+\func{fseeko} e \func{ftello}, che sono assolutamente identiche alle
+precedenti \func{fseek} e \func{ftell} ma hanno argomenti di tipo
+\type{off\_t} anziché di tipo \ctyp{long int}. Dato che \ctyp{long} è nella
+gran parte dei casi un intero a 32 bit, questo diventa un problema quando la
+posizione sul file viene espressa con un valore a 64 bit come accade nei
+sistemi più moderni.
+
+% TODO: mettere prototipi espliciti fseeko e ftello o menzione?