Preprocessing

In informatica, e in particolare nella terminologia dei linguaggi di programmazione, il preprocessing (o precompilazione) è una fase dell'elaborazione del codice sorgente che precede la compilazione. Il programma che esegue questa elaborazione viene detto precompilatore o preprocessore.

Le trasformazioni che il preprocessore è in grado di eseguire sul codice sono in genere relativamente semplici; un esempio tipico è la sostituzione sistematica di determinate sequenze di caratteri del file sorgente con un testo più complesso (macro) o con il contenuto di un altro file sorgente. Il risultato della precompilazione è ancora codice sorgente, ovvero la precompilazione non include nessuno dei passaggi necessari alla generazione del codice macchina, che rimane appannaggio del compilatore vero e proprio.

Il sistema di precompilazione più noto è quello associato al linguaggio C, e gran parte della terminologia usata con riferimento al preprocessing in generale è mutuata da quella del C.

In generale, il preprocessore è in grado di interpretare alcune porzioni di codice sorgente che utilizzano una sintassi esplicitamente dedicata al preprocessing; nella terminologia C queste porzioni di codice si dicono direttive per il preprocessore (o direttive di precompilazione).

Esempi di direttive di precompilazione C

In C, le direttive per il precompilatore sono marcate dal simbolo iniziale #.

Macro

In C, la parola chiave #define definisce una macro, una direttiva che richiede la sostituzione di una sequenza di caratteri con un'altra. Per esempio, nel seguente estratto di codice si chiede di sostituire ovunque nel codice sorgente la parola MAXBYTES con 80.

#define MAXBYTES 80 
int main(int argc, char * argv[]) 
{
    int i;
    char buffer[MAXBYTES];

    for(i=0; i<MAXBYTES; i++)
    buffer[i] = 0;
    ...
}

Dopo la precompilazione il codice diventa:

int main(int argc, char * argv[]) 
{
    int i;
    char buffer[80];
    
    for(i=0; i<80; i++)
    buffer[i] = 0;
    ...
}

Include

La direttiva #include indica al preprocessore di includere in questo sorgente dell'altro codice sorgente proveniente da un altro file.

Espansione condizionale

Le direttive #ifdef e #endif permettono di includere o escludere dal codice una certa sezione di codice a seconda che sia definita o meno una determinata macro:

#define DEBUG
...
#ifdef DEBUG
printf(...);
#endif
...

Nel nostro esempio il preprocessore lascerà la linea con la printf se e solo se la macro DEBUG è stata definita. Questa direttiva è utile quando all'interno del codice si inseriscono linee per il debugging dell'applicazione, come ad esempio linee di stampa di valori di variabile; se in alcuni casi non necessitiamo di stampare queste linee (in assenza di direttive) saremmo costretti a commentare le linee di debugging, ed eventualmente scommentarle in caso di necessità. Un altro aspetto di utilità è l'adattamento alla piattaforma. Uno stesso codice potrebbe dover girare su un sistema Unix o un sistema Windows, con chiamate a librerie diverse. La definizione di queste direttive potrebbe aiutare in questo compito.

Linguaggi derivati dal C

I linguaggi C++, C# e altri linguaggi derivati dal C ereditano molte direttive del C (o tutte) e tipicamente ne aggiungono di ulteriori; per esempio, fra le direttive C# non derivate dal C si possono citare #warning, #error, #line, #region, e #endregion