Un'istruzione può essere una delle seguenti:

• Istruzione composta
• Istruzione di controllo
• Istruzione di espressione
• Istruzione integrata
• Definizione costante
• Definizione variabile

Le istruzioni specificano il flusso di controllo durante l'esecuzione di un ULP. In assenza di istruzioni di controllo specifiche, le istruzioni vengono eseguite in sequenza in base all'ordine di aspetto nel file ULP.

Istruzione composta

Un'istruzione composta, nota anche come blocco, è un elenco (possibilmente vuoto) di istruzioni racchiuse tra parentesi graffe corrispondenti ({ }). Dal punto di vista della sintassi, un blocco può essere considerato come una singola istruzione, ma controlla anche l'ambito degli identificatori. L'ambito di un identificatore dichiarato all'interno di un blocco inizia nel punto di dichiarazione e termina in corrispondenza della parentesi graffa di chiusura.

Le istruzioni composte possono essere nidificate a qualsiasi profondità.

Istruzione di espressione

Un'istruzione di espressione è un'espressione qualsiasi seguita da un punto e virgola.

Un'istruzione di espressione viene eseguita valutando l'espressione. Tutti gli effetti collaterali di questa valutazione vengono completati prima dell'esecuzione della successiva istruzione. La maggior parte delle istruzioni di espressione sono assegnazioni o chiamate di funzione.

Un caso speciale è l'istruzione vuota, costituita solo da un punto e virgola. Un'istruzione vuota non esegue alcuna operazione, ma può essere utile in situazioni in cui la sintassi ULP richiede un'istruzione, ma questa non è richiesta dal programma.

Istruzioni di controllo

Le istruzioni di controllo vengono utilizzate per controllare il flusso del programma.

Le istruzioni di iterazione sono

do...while
for
while

Le istruzioni di selezione sono

if...else
switch

Le istruzioni di salto sono

break
continue
return

break

La sintassi generale dell'istruzione break è

break;

e termina immediatamente l'istruzione do...while, for, switch or while di inclusione più vicina. Questa opzione è valida anche per i membri del loop di tipi di oggetto.

Poiché tutte queste istruzioni possono essere mescolate e nidificate a qualsiasi profondità, assicurarsi che l'istruzione break determini l'uscita dall'istruzione corretta.

continue

La sintassi generale dell'istruzione continue è

continue;

e trasferisce immediatamente il controllo alla condizione di test dell'istruzione do...while, while o for di inclusione più vicina, o all'espressione di incremento dell'istruzione di inclusione più vicina.

Poiché tutte queste istruzioni possono essere mescolate e nidificate a qualsiasi profondità, assicurarsi che l'istruzione continue influenzi l'istruzione corretta.

do...while

La sintassi generale dell'istruzione do...while è

do statement while (condition);

ed esegue l'istruzione finché l'espressione della condizione non diventa zero. La condizione viene verificata dopo la prima esecuzione dell'istruzione, il che significa che l'istruzione viene sempre eseguita almeno una volta.

Se non contiene break o return, l'istruzione deve influenzare il valore della condizione, oppure la condizione stessa deve cambiare durante la valutazione per evitare un loop infinito.

Esempio:

string s = "Trust no one!";
int i = -1;
do {
   ++i;
   } while (s[i]);

for

La sintassi generale dell'istruzione for è

for ([init]; [test]; [inc]) statement

ed esegue i passaggi seguenti:

1. Se è presente un'espressione di inizializzazione init, verrà eseguita.
2. Se è presente un'espressione test, verrà eseguita. Se il risultato è diverso da zero (o se non è presente alcuna espressione di test), viene eseguita l'istruzione.
3. Se è presente un'espressione inc, verrà eseguita.
4. Il controllo ritorna infine al passaggio 2.

Se l'istruzione non contiene break o return, l'espressione inc (o l'istruzione) deve influire sul valore dell'espressione di prova o il test stesso deve cambiare durante la valutazione per evitare un loop infinito.

L'espressione di inizializzazione init normalmente inizializza uno o più contatori di loop. È inoltre possibile definire una nuova variabile come contatore di loop. L'ambito di tale variabile è valido fino alla fine del blocco che racchiude la sequenza chiusa for.

Esempio:

string s = "Trust no one!";
int sum = 0;
for (int i = 0; s[i]; ++i)
    sum += s[i]; // sums up the characters in s

if...else

La sintassi generale dell'istruzione if...else è

if (expression)
   t_statement
[else
   f_statement]

L'espressione condizionale viene valutata e se il relativo valore è diverso da zero, viene eseguita l'istruzione t_statement. In caso contrario, l'istruzione f_statement viene eseguita nel caso in cui sia presente una clausola else.

Una clausola else è sempre abbinata all'ultima istruzione if rilevata senza un else. Se questo non è quello desiderato, è necessario utilizzare le parentesi graffe per raggruppare le istruzioni, come in

if (a == 1) {
   if (b == 1)
      printf("a == 1 and b == 1\n");
   }
else
   printf("a != 1\n");

torna

Una funzione con un tipo return diverso da void deve contenere almeno un'istruzione return con la sintassi

return expression;

dove expression deve essere valutata rispetto a un tipo compatibile con il tipo return della funzione. Il valore di expression è il valore restituito dalla funzione.

Se la funzione è di tipo void, è possibile utilizzare un'istruzione return senza expression per tornare dalla chiamata di funzione.

switch

La sintassi generale dell'istruzione switch è

switch (sw_exp) {
  case case_exp: case_statement
  ...
  [default: def_statement]
  }

e consente di trasferire il controllo ad una delle diverse istruzioni con etichetta case, a seconda del valore di sw_exp (che deve essere di tipo integrale).

Qualsiasi istruzione case_statement può essere etichettata mediante una o più etichette case. Il valore case_exp di ogni etichetta case deve essere valutato come un numero intero costante che è univoco all'interno dell'istruzione switch che lo racchiude.

Deve inoltre essere presente al massimo un'etichetta default.

Dopo la valutazione di sw_exp, case_exp viene verificata per una corrispondenza. Se viene trovata una corrispondenza, il controllo passa al case_statement con l'etichetta case corrispondente. Se non viene trovata alcuna corrispondenza ed esiste un'etichetta di default, il controllo passa a def_statement. In caso contrario, nessuna delle istruzioni nello switch viene eseguita.

L'esecuzione del programma non è influenzata quando vengono rilevate etichette case e default. Il controllo passa semplicemente tramite le etichette all'istruzione seguente.

Per interrompere l'esecuzione alla fine di un gruppo di istruzioni per un case specifico, utilizzare l'istruzione break.

Esempio:

string s = "Hello World";
int vowels = 0, others = 0;
for (int i = 0; s[i]; ++i)
    switch (toupper(s[i])) {
      case 'A':
      case 'E':
      case 'I':
      case 'O':
      case 'U': ++vowels;
                break;
      default: ++others;
      }
printf("There are %d vowels in '%s'\n", vowels, s);

while

La sintassi generale dell'istruzione while è

while (condition) statement

ed esegue l'istruzione finché l'espressione condition non è zero.

La condizione viene verificata prima della prima esecuzione dell'istruzione, ovvero se condition è inizialmente zero, l'istruzione potrebbe non essere mai eseguita.

Se non contiene break o return, l'istruzione deve influenzare il valore della condizione, oppure condition stessa deve cambiare durante la valutazione per evitare un loop infinito.

Esempio:

string s = "Trust no one!";
int i = 0;
while (s[i])
      ++i;