--- /dev/null
+\chapter{Gestione di parametri e opzioni}
+
+Il passaggio dei parametri e delle variabili di ambiente dalla riga di comando
+al singolo programma quando viene lanciato è effettuato attraverso le
+variabili \texttt{argc}, \texttt{argv}, queste vengono passate al programma
+come argomenti della funzione principale:
+
+\begin{verbatim}
+ main(int argc, char * argv[])
+\end{verbatim}
+
+\section{Il formato dei parametri}
+
+Il passaggio dei parametri al programma viene effettuato dalla shell, che si
+incarica di leggere la linea di comando e di effettuarne la scansione (il
+cosiddetto \textit{parsing}) per individuare le parole che la compongono,
+ciascuna delle quali viene considerata un parametro; di default per
+individuare le parole viene usato come separatore lo spazio (comportamento
+modificabile attraverso il settaggio della variabile di ambiente IFS).
+
+Nella scansione viene costruito l'array di puntatori \texttt{argv} inserendo
+in successione il puntatore alla stringa costituente l'$n$-simo parametro; la
+variabile \texttt{argc} viene inizializzata al numero di parametri trovati, in
+questo modo il primo parametro è sempre il nome del programma (vedi \nfig).
+
+\section{La gestione delle opzioni}
+
+In generale un programma unix riceve da linea di comando sia i parametri che
+le opzioni, queste ultime sono standardizzate per essere riconosciute come
+tali: un elemento di \texttt{argv} che inizia con \texttt{-} e che non sia un
+singolo \texttt{-} o \texttt{--} viene considerato un'opzione. In in genere
+le opzioni sono costituite da un lettera preceduta dal meno e possono avere o
+no un parametro associato; un comando tipico può essere cioè qualcosa del
+tipo:
+\begin{verbatim}
+touch -r riferimento.txt -m questofile.txt
+\end{verbatim}
+ed in questo caso le opzioni sono \texttt{m} ed \texttt{r}.
+
+Per gestire le opzioni all'interno dei parametri passati in \texttt{argv} le
+librerie standard del C forniscono la funzione \texttt{getopt} (accessibile
+includendo \texttt{unistd.h}), che ha il prototipo:
+\begin{verbatim}
+int getopt(int argc, char * const argv[], const char * optstring);
+\end{verbatim}
+
+Questa funzione prende come argomenti le due variabili \texttt{argc} e
+\texttt{argv} ed una stringa che indica quali sono le opzioni valide; la
+funzione effettua la scansione della lista dei parametri ricercando ogni
+stringa che comincia con \texttt{-} e ritorna ogni volta che trova una opzione
+valida.
+
+La stringa \texttt{optstring} indica quali sono le opzioni riconosciute ed è
+costituita da tutti i caratteri usati per identificare le singole opzioni, se
+l'opzione ha un parametro al carattere deve essere fatto seguire un segno di
+due punti \texttt{:} nel caso appena accennato ad esempio la stringa di
+opzioni sarebbe \texttt{"r:m"}.
+
+La modalità di uso è pertanto quella di chiamare più volte la funzione
+all'interno di un ciclo di while fintanto che essa non ritorna il valore
+\texttt{-1} che indica che non ci sono più opzioni. Nel caso si incontri
+un'opzione non dichiarata in \texttt{optstring} viene ritornato un \texttt{?}
+mentre se l'opzione non è seguita da un parametro viene ritornato un
+\texttt{:} infine se viene incontrato il valore \texttt{--} la scansione viene
+considerata conclusa.
+
+Quando la funzione trova un'opzione essa ritorna il valore numerico del
+carattere, in questo modo si possono prendere le azioni relative usando un
+case; la funzione inizializza inoltre alcune varibili globali:
+\begin{itemize}
+\item \texttt{char * optarg} contiene il puntatore alla stringa argomento
+ dell'opzione.
+\item \texttt{int optind} alla fine della scansione restituisce l'indice del
+ primo argomento che non è un'opzione.
+\item \texttt{int opterr} previene, se posto a zero, la stampa di un messaggio
+ di errore in caso di riconoscimento di opzioni non definite.
+\item \texttt{int optopt} contiene il carattere dell'opzione non riconosciuta.
+\end{itemize}
+
+In \nfig è mostrato un programma di esempio,
+
+\begin{figure}[htbp]
+ \begin{center}
+ \begin{verbatim}
+ opterr = 0; /* don't want writing to stderr */
+ while ( (i = getopt(argc, argv, "o:a:i:hve")) != -1) {
+ switch (i) {
+ case 'i': /* input file */
+ in_file=open(optarg,O_RDONLY);
+ if (in_file<0) {
+ perror("Cannot open input file");
+ exit(1);
+ }
+ break;
+ case 'o': /* output file (overwrite) */
+ out_file=open(optarg,O_WRONLY|O_CREAT);
+ if (out_file<0) {
+ perror("Cannot open output file");
+ exit(1);
+ }
+ break;
+ break;
+ case 'a': /* output file (append) */
+ out_file=open(optarg,O_WRONLY|O_CREAT|O_APPEND);
+ break;
+ case 'h': /* print help usage */
+ usage();
+ break;
+ case 'v': /* set verbose mode */
+ debug("Option -v active\n");
+ verbose=1;
+ break;
+ case '?': /* unrecognized options */
+ printf("Unrecognized options -%c\n",optopt);
+ usage();
+ default: /* should not reached */
+ debug("default option\n");
+ usage();
+ }
+ }
+ debug("Optind %d, argc %d\n",optind,argc);
+ \end{verbatim}
+ \caption{Esempio di codice per la gestione delle opzioni.}
+ \label{fig:options_code}
+ \end{center}
+\end{figure}
+
+\subsection{Opzioni in formato esteso}
+
+Un'estensione di questo schema è costituito dalle cosiddette
+\textit{long-options} espresse nella forma \texttt{--option=parameter}, anche
+la gestione di queste ultime è stata standardizzata attraverso l'uso di una
+versione estesa di \texttt{getopt}.
+
+
+\section{Le variabili di ambiente}
+
+Questo va fatto.
+
+
+
+
+
+
+
projects / gapil.git / blobdiff