\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.







