Les différents types d’instructions sont les suivants :

• Instruction composée
• Instruction de contrôle
• Instruction d’expression
• Instruction intégrée
• Définition de constante
• Définition de variable

Les instructions spécifient le flux de contrôle lorsque le programme de langage utilisateur s’exécute. En l’absence d’instructions de contrôle spécifiques, les instructions sont exécutées de manière séquentielle, dans leur ordre d’apparition dans le fichier ULP.

Instruction composée

Une instruction composée, également appelée bloc, est une liste (éventuellement vide) d’instructions entre accolades ({ }). Du point de vue syntaxique, un bloc peut être considéré comme une instruction unique, mais il contrôle aussi la portée des identificateurs. La portée d’un identificateur déclaré dans un bloc commence au point de déclaration et se termine au niveau de l’accolade fermante.

Les instructions composées peuvent être imbriquées sur n’importe quelle profondeur.

Instruction d’expression

Une instruction d’expression est une expression suivie d’un point-virgule.

L’exécution d’une instruction d’expression consiste à évaluer l’expression. L’exécution de l’instruction suivante ne commence que si tout effet secondaire de cette évaluation est terminé. La plupart des instructions d’expression sont des affectations ou des appels de fonction.

L’instruction vide (composée uniquement d’un point-virgule) est un cas particulier. Une instruction vide ne fait rien, mais elle peut s’avérer utile lorsque la syntaxe ULP attend une instruction, alors que votre programme n’en a pas besoin.

Instructions de contrôle

Les instructions de contrôle permettent de contrôler le flux du programme.

Les instructions d’itération sont :

do...while
for
while

Les instructions de sélection sont :

if...else
switch

Les instructions de saut sont :

break
continue
return

break

La syntaxe générale de l’instruction break est la suivante :

break;

Elle met immédiatement fin à l’instruction do...while, for, switch ou while la plus proche. Cela s’applique également aux membres de boucle pour les types d’objets.

Comme toutes ces instructions peuvent être combinées et imbriquées sur n’importe quelle profondeur, veillez à ce que l’instruction break mette fin à l’instruction pertinente.

continue

La syntaxe générale de l’instruction continue est la suivante :

continue;

Elle transfère immédiatement le contrôle à la condition de test de l’instruction do...while, while ou for la plus proche ou à l’expression d’incrément de l’instruction englobante for la plus proche.

Comme toutes ces instructions peuvent être combinées et imbriquées sur n’importe quelle profondeur, veillez à ce que l’instruction continue ait un impact sur l’instruction pertinente.

do...while

La syntaxe générale de l’instruction do...while est la suivante :

do statement while (condition);

Elle exécute l’instruction jusqu’à ce que l’expression de la condition devienne nulle. La condition est testée après la première exécution de l’instruction. Autrement dit, l’instruction est toujours exécutée au moins une fois.

Si l’instruction ne contient ni break ni return, elle doit avoir un impact sur la valeur de la condition, ou la condition elle-même doit changer lors de l’évaluation, afin d’éviter une boucle infinie.

Exemple :

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

for

La syntaxe générale de l’instruction for est la suivante :

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

Elle effectue les opérations suivantes :

1. Si une expression d’initialisation [init] est présente, elle est exécutée.
2. Si une expression [test] est présente, elle est exécutée. Si le résultat est non nul (ou en l’absence d’expression de test), l’instruction est exécutée.
3. Si une expression [inc] est présente, elle est exécutée.
4. Enfin, le contrôle revient à l’étape 2.

Si l’instruction ne contient ni break ni return, l’expression inc (ou l’instruction) doit avoir un impact sur la valeur de l’expression test, ou le test lui-même doit changer lors de l’évaluation, afin d’éviter une boucle infinie.

Normalement, l’expression d’initialisation init initialise un ou plusieurs compteurs de boucle. Elle peut également définir une nouvelle variable comme compteur de boucle. La portée d’une telle variable est valide jusqu’à la fin du bloc contenant la boucle for.

Exemple :

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 syntaxe générale de l’instruction if...else est la suivante :

if (expression)
   t_statement
[else
   f_statement]

L’expression conditionnelle est évaluée et, si sa valeur est non nulle, l’instruction t_statement est exécutée. Sinon, si une clause else est présente, l’instruction f_statement est exécutée.

Une clause else est toujours mise en correspondance avec la dernière clause if sans else. Si ce n’est pas ce que vous souhaitez, vous devez utiliser des accolades pour regrouper les instructions, comme dans :

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

return

Une fonction avec un type de retour autre que void doit contenir au moins une instruction return, dont la syntaxe est la suivante :

return expression;

où expression doit correspondre à un type compatible avec le type de retour de la fonction. La valeur renvoyée par la fonction est la valeur de l’expression.

Si la fonction est de type void, vous pouvez utiliser une instruction de retour sans expression pour revenir de l’appel de fonction.

switch

La syntaxe générale de l’instruction switch est la suivante :

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

Elle permet de transférer le contrôle à l’une des différentes instructions dotées d’étiquette de cas, selon la valeur de l’expression sw_exp (qui doit être de type entier).

Toute instruction case_statement peut être étiquetée par une ou plusieurs étiquettes de cas. L’expression case_exp de chaque étiquette de cas doit correspondre à une constante de type entier qui est unique dans l’instruction switch.

Vous pouvez également définir une étiquette par défaut.

Après évaluation de sw_exp, le programme recherche une correspondance pour chaque expression case_exp. S’il trouve une correspondance, le contrôle passe à l’instruction case_statement associée à cette étiquette de cas. Si aucune correspondance n’est trouvée et qu’il existe une étiquette par défaut, la commande passe à l’instruction par défaut def_statement. Sinon, aucune des instructions étiquetées dans l’instruction switch n’est exécutée.

L’identification des étiquettes case et default n’a pas d’impact sur l’exécution du programme. Le contrôle se contente de passer à l’instruction suivante.

Pour arrêter l’exécution à la fin d’un groupe d’instructions correspondant à un cas particulier, utilisez l’instruction break.

Exemple :

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 syntaxe générale de l’instruction while est la suivante :

while (condition) statement

Elle exécute l’instruction tant que l’expression condition n’est pas nulle.

La condition étant testée avant la première exécution possible de l’instruction, l’instruction ne sera jamais exécutée si la condition est initialement nulle.

Si l’instruction ne contient ni break ni return, elle doit avoir un impact sur la valeur de la condition, ou la condition elle-même doit changer lors de l’évaluation, afin d’éviter une boucle infinie.

Exemple :

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