Syntaxe de Pseudo-Pascal

La syntaxe de notre langage est quasiment celle de Pascal. Si on connaît déjà Pascal on est un peu aidé.

Voici donc sa description informelle, accompagnée d’exemples illustratifs. A chaque fois qu’une sous-partie est facultative dans une définition, on la fait suivre de ceci : (f).

Un programme est introduit par le mot-clé program et est constitué dans l’ordre de déclarations de variables (f), de définitions de procédures ou de fonctions (f), et d’un bloc d’instructions.

Les définitions de procédures sont introduites par le mot-clé procedure. Elles sont composées du nom de la procédure, de la liste de ses arguments (f) entre parenthèses terminée par un point-virgule, des déclarations de variables locales et d’un bloc d’instructions terminé par un point-virgule. Par exemple :

procedure affiche (e : array of integer; i, j : integer);
var k : integer;
begin
  ...
end;

Les définitions de fonctions sont similaires aux définitions de procédures. Elles sont introduites par le mot-clé function, et la liste de leurs arguments est suivie de deux-points puis du type de retour attendu. Par exemple :

function affiche (e : array of integer; i, j : integer) : boolean;
var k : integer;
begin
  ...
end;

Les déclarations de variables (globales ou locales) sont introduites par le mot-clé var. Comme en Pascal, elles autorisent la déclaration simultanée de plusieurs variables de même type. La syntaxe est la suivante : les noms de variables sont séparés par des virgules, suivis de deux-points, puis vient le nom du type. Ces listes de déclarations sont séparées par des point-virgules. Plusieurs listes de variables peuvent ainsi être déclarées, aucune de ces listes ne pouvant être vide. Le tout se termine par un point-virgule. Par exemple :

var r : array of integer;
    i, j : integer;

La liste des arguments utilisée dans la définition d’une procédure ou d’une fonction suit les mêmes règles à l’exception de l’utilisation de var au début et du point-virgule à la fin.

Un bloc d’instructions est une liste d’instructions (f) séparées par des points-virgules, entre les mots-clés begin et end.

Une instruction peut être de différentes sortes :

• une affectation de variable consiste en un nom de variable suivi de := puis d’une expression.
• une affectation dans un tableau consiste en une expression qui donne le tableau suivi d’une expression entre crochets qui donne l’index suivi de := puis d’une expression.
• un appel de procédure consiste en un nom de procédure suivi d’une liste d’expressions (f), séparées par des virgules, entre parenthèses.
• une conditionnelle à une seule alternative commence par le mot-clé if suivi d’une condition, du mot-clé then et d’une instruction ou un bloc d’instructions.
• une conditionnelle à deux alternatives commence comme la conditionnelle à une alternative, suivie du mot-clé else et d’une instruction ou un bloc d’instructions.
• une boucle commence par le mot-clé while suivi d’une condition, du mot-clé do et d’une instruction ou un bloc d’instructions.

Une expression peut aussi être de différentes sortes :

• une constante de type booléen ou entier.
• une lecture de variable consiste en le nom de cette variable.
• une opération unaire consiste en un opérateur unaire suivi d’une expression.
• une opération binaire consiste en deux expressions séparées par un opérateur binaire.
• une lecture dans un tableau consiste en une expression qui donne le tableau suivi d’une expression entre crochets qui donne l’index.
• un appel de fonction consiste en un nom de fonction suivi d’une liste d’expressions (f), séparées par des virgules, entre parenthèses.
• une allocation de tableau consiste en la suite de mots-clés new, array et of suivie d’un type et d’une expression entre crochet qui donne la taille du tableau.
• une expression entre parenthèses.

Les opérateurs binaires sont les opérateurs arithmétiques habituels (+ - / *), l’égalité (=), les opérateurs de comparaison (<> < > <= >=) et les opérateurs logiques (and or). Les opérateurs unaires sont la négation arithmétique (-) et la négation logique (not).

La syntaxe des expressions est tout-à-fait standard. Les ambiguïtés engendrées par la règle des opérateurs binaires sont levées par les conventions usuelles sur les priorités relatives des opérateurs. Les ambiguïtés relatives aux accès dans les tableaux seront levées selon la raison, (penser par exemple à « t[0] + t[1] » qui s’interprète comme « (t[0]) + (t[1]) ».

Enfin, la syntaxe des types est inspirée de celle de Pascal, mais en beaucoup plus simple, car notre seul type construit est celui des tableaux. Le type entier s’appelle integer, le type booléen s’appelle boolean et le type tableau de «t» s’appelle array of «t».

Ce document a été traduit de L^AT_EX par H^EV^EA