\subsection{Come chiudere un programma}
-\label{sec:proc_termination}
+\label{sec:proc_conclusion}
La via normale per la quale un programma finisce è quando la funzione
\func{main} ritorna, una modalità equivalente di conclusione è quella di
Oltre alla conclusione ``normale'' esiste anche la possibilità di una
conclusione ``anomala'' del programma a causa di segnali o della chiamata alla
funzione \func{abort} (che comunque genera un segnale che termina il
-programma); torneremo su questo in \secref{sec:sig_prog_error}.
+programma); torneremo su questo in \secref{sec:proc_termination}.
Il valore di ritorno della funzione main, o quello usato nelle chiamate ad
\func{exit} e \func{\_exit}, viene chiamato \textit{exit status} e passato
possibile un processo possa essere terminato (da un segnale) prima che il
programma in esecuzione si sia concluso. In caso di conclusione normale del
programma però lo stato di uscita diventa parte dello stato di conclusione del
-processo (vedi \secref{sec:proc_xxx}).
+processo (vedi \secref{sec:proc_termination}).
\subsection{Le funzioni \func{exit} e \func{\_exit}}
\begin{functions}
\headdecl{stdlib.h}
\funcdecl{void *calloc(size\_t size)}
- Alloca \var{size} bytes nello heap. La memoria viene inizializzata a 0.
+ Alloca \var{size} byte nello heap. La memoria viene inizializzata a 0.
La funzione restituisce il puntatore alla zona di memoria allocata in caso
di successo e \macro{NULL} in caso di fallimento, nel qual caso
\var{errno} viene settata a \macro{ENOMEM}.
\funcdecl{void *malloc(size\_t size)}
- Alloca \var{size} bytes nello heap. La memoria non viene inizializzata.
+ Alloca \var{size} byte nello heap. La memoria non viene inizializzata.
La funzione restituisce il puntatore alla zona di memoria allocata in caso
di successo e \macro{NULL} in caso di fallimento, nel qual caso
La memoria allocata dinamicamente deve essere esplicitamente rilasciata usando
\func{free}\footnote{le glibc provvedono anche una funzione \func{cfree}
- defininita per compatibilità con SunOS, che è deprecata} una volta che non
+ definita per compatibilità con SunOS, che è deprecata} una volta che non
sia più necessaria. Questa funzione vuole come parametro un puntatore
restituito da una precedente chiamata a una qualunque delle funzioni di
allocazione e che non sia già stato liberato da un'altra chiamata a
la dimensione di un'area di memoria precedentemente allocata, la funzione
vuole in ingresso il puntatore restituito dalla precedente chiamata ad una
\func{malloc} (se è passato un valore \macro{NULL} allora la funzione si
-comporta come \func{malloc}\footnote{questo è vero per linux e
+comporta come \func{malloc}\footnote{questo è vero per Linux e
l'implementazione secondo lo standard ANSI C, ma non è vero per alcune
vecchie implementazioni, inoltre alcune versioni delle librerie del C
consentivano di usare \func{realloc} anche per un puntatore liberato con
\func{free} purché non ci fossero state altre chiamate a funzioni di
allocazione, questa funzionalità è totalmente deprecata e non è consentita
- sotto linux}), ad esempio quando si deve far crescere la dimensione di un
+ sotto Linux}), ad esempio quando si deve far crescere la dimensione di un
vettore; in questo caso se è disponibile dello spazio adiacente al precedente
la funzione lo utilizza, altrimenti rialloca altrove un blocco della dimensione
voluta copiandoci automaticamente il contenuto, lo spazio in più non viene
versione meno efficiente delle funzioni, che però è più tollerante nei
confronti di piccoli errori come quello di chiamate doppie a \func{free}; in
particolare:
-\begin{itemize}
+\begin{itemize*}
\item se la variabile è posta a zero gli errori vengono ignorati.
\item se è posta ad 1 viene stampato un avviso sullo \textit{standard error}
(vedi \secref{sec:file_stdfiles}).
\item se è posta a 2 viene chiamata \func{abort}, che in genere causa
l'immediata conclusione del programma.
-\end{itemize}
+\end{itemize*}
Il problema più comune e più difficile da tracciare che si incontra con
l'allocazione della memoria è però quando la memoria non più utilizzata non
\texttt{alloca} che invece che allocare la memoria nello heap usa lo il
segmento di stack della funzione corrente. La sintassi è identica:
\begin{prototype}{stdlib.h}{void *alloca(size\_t size)}
- Alloca \texttt{size} bytes nel segmento di stack della funzione chiamante.
+ Alloca \texttt{size} byte nel segmento di stack della funzione chiamante.
La memoria non viene inizializzata.
La funzione restituisce il puntatore alla zona di memoria allocata in caso
non è possibile aumentare le dimensioni dello stack una volta chiamata una
funzione e quindi l'uso limita la portabilità dei programmi, inoltre se si
cerca di allocare troppa memoria non si ottiene un messaggio di errore, ma un
-segnale di \textit{segmentation violation} analogo a quello che si avrebbe da
-una ricorsione infinita.
+segnale di \textit{segment violation} analogo a quello che si avrebbe da una
+ricorsione infinita.
Inoltre non è chiaramente possibile usare questa funzione per allocare memoria
che deve poi essere usata anche al di fuori della funzione in cui questa viene
Il controllo del flusso di un programma in genere viene effettuato con le
varie istruzioni del linguaggio C, la più bistrattata delle quali è il
-\texttt{goto}, ampiamente deprecato in favore di costrutti più puliti; esiste
+\func{goto}, ampiamente deprecato in favore di costrutti più puliti; esiste
però un caso in l'uso di questa istruzione porta all'implementazione più
efficiente, quello dell'uscita in caso di errore.
annidate occorre usare la funzione \func{longjump}.
+
+
+
\section{La gestione di parametri e opzioni}
\label{sec:proc_options}
La funzione esegue il parsing degli argomenti passati da linea di comando
riconoscendo le possibili opzioni segnalate con \var{optstring}.
-Ritorna il carattere che segue l'opzione, \cmd{:} se manca un paramatro
+Ritorna il carattere che segue l'opzione, \cmd{:} se manca un parametro
all'opzione, \cmd{?} se l'opzione è sconosciuta, e -1 se non esistono altre
opzioni.
\end{prototype}
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 variabili globali:
-\begin{itemize}
-\item \texttt{char * optarg} contiene il puntatore alla stringa argomento
+\begin{itemize*}
+\item \var{char * optarg} contiene il puntatore alla stringa argomento
dell'opzione.
-\item \texttt{int optind} alla fine della scansione restituisce l'indice del
+\item \var{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
+\item \var{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}
+\item \var{int optopt} contiene il carattere dell'opzione non riconosciuta.
+\end{itemize*}
In \nfig\ è mostrato un programma di esempio:
\begin{figure}[htbp]
exit(1);
}
break;
- break;
case 'a': /* output file (append) */
out_file=open(optarg,O_WRONLY|O_CREAT|O_APPEND);
break;
\label{fig:proc_options_code}
\end{figure}
+
\subsection{Opzioni in formato esteso}
\label{sec:proc_opt_extended}
(NdA: da finire).
+
\subsection{Le variabili di ambiente}
\label{sec:proc_environ}
chiamata ad \func{exec} che lo ha lanciato.
Come per la lista dei parametri anche questa lista è un array di puntatori a
-caratteri, ciascuno dei quali punta ad una stringa (terminata da un null). A
+caratteri, ciascuno dei quali punta ad una stringa (terminata da un NULL). A
differenza di \var{argv[]} però in questo caso non si ha la lunghezza
dell'array dato da un equivalente di \var{argc}, ma la lista è terminata da un
puntatore nullo.
in \curfig, sono definite dal sistema per queste c'è la convezione di usare
nomi espressi in caratteri maiuscoli.
-Il kernel non usa mai queste variabili, il loro uso e la loro intepretazione è
+Il kernel non usa mai queste variabili, il loro uso e la loro interpretazione è
riservata alle applicazioni e ad alcune funzioni di libreria; in genere esse
costituiscono un modo comodo per definire un comportamento specifico senza
dover ricorrere all'uso di opzioni a linea di comando o di file di
Gli standard POSIX e XPG3 definiscono alcune di queste variabili (le più
comuni), come riportato in \ntab. GNU/Linux le supporta tutte e ne definisce
-anche altre per una lista parziale si può controllare \cmd{man environ}
+anche altre per una lista parziale si può controllare \cmd{man environ}.
+
+
+
+
+
projects / gapil.git / blobdiff