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 définition sous forme genre BNF, il s'agit presque d'une grammaire mais avec des méta-notations, généralement exprimées à l'aide des constructions des expressions régulières, plus les notations [item sep  ...  sep item] qui signifie une liste non vide d'items séparés par sep, et [item sep  ...  sep item]? qui signifie une liste possiblement vide d'items séparés par sep.

Les terminaux sont en gras, les non-terminaux en italiques et les méta-notations en vert.

Les prorammes sont introduits par le mot-clé program et constitués de déclarations de variables (qui sont optionelles) suivies des définitions des procédures ou des fonctions, suivies d'une liste d'instructions. Autrement dit :
program      ::=      program (vars)? (definition ; )* begin [instruction ;  ...  ; instruction] end.     

Les déclarations de variables sont introduites par le mot-clé var et un peu compliquées selon le schéma de Pascal qui autorise la déclaration simultanée de plusieurs variables possédant le même type.
vars      ::=      var ( varsdecl ; )+     
      
varsdecl      ::=      [ident ,  ...  , ident] : type     
      

Bon j'arrête de paraphraser les règles de grammaire, voici donc toutes les autres règles en commençant par la définition de procédure ou de fonction et en poursuivant par les instructions.
definition      ::=      procedure ident ( [varsdecl ;  ...  ; varsdecl]? ) ; body     
              function ident ( [varsdecl ;  ...  ; varsdecl]? ) : type ; body     
      
body      ::=      (vars)? begin [instruction ;  ...  ; instruction] end     
      
instruction      ::=      ident := expression      affectation (d'une variable)
              expression [ expression ] := expression      affectation (dans un tableau)
              procedureident ( [expression ,  ...  , expression]? )      appel de procédure
              begin [instruction ;  ...  ; instruction] end      séquence
              if expression then instruction else instruction      conditionelle
              while expression do instruction      boucle
      
procedureident      ::=      read | write | writeln | ident      trois primitives ou
un identificateur général

La syntaxe des expressions est ensuite tout à fait standard, les ambigüités engendrées par la règle des opérateurs binaires sont levées par les convention usuelles sur les priorités relatives des opérateurs. Par ailleurs 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]) ».
expression      ::=      int | true | false      constantes
              ident      reférence à une variable
              ident ( [expression ,  ...  , expression]? )      appel de fonction
              alloc ( expression : type )      allocation dynamique
              - expression      moins unaire (négation)
              expression binop expression      notation infixe des opérations binaire
              expression [ expression ]      accès dans les tableaux
              ( expression )      parenthésage
      
binop      ::=      + | - | / | * | = | <> | < | > | <= | >=      opérateurs binaires

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.
type      ::=      integer | boolean       
              array of type     

Ce document a été traduit de LATEX par HEVEA.