<figure><img src="image_1.png" /></figure>

HAL
open science

# Projet delta : description d'un langage algorithmique a
structures de blocs

France Blaizot, Pierre Boullier

► To cite this version:

France Blaizot, Pierre Boullier. Projet delta : description d'un langage algorithmique a structures de blocs. [Rapport de recherche] IRIA-RR-035, IRIA. 1973, pp.37. hal-04715931

HAL Id: hal-04715931

https://inria.hal.science/hal-04715931v1

Submitted on 1 Oct 2024

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_2.png" /></figure>

Distributed under a Creative Commons Attribution 4.0 International License
RIA
laboria

laboratoire de recherche
en informatique
et automatique

# Projet DELTA
Description d'un
langage algorithmique
à structure de blocs

F.Blaizot
P.Boullier

<figure><img src="image_3.png" /></figure>

Institut de Recherche
d'Informatique
et d'Automatique

Domaine de Voluceau
Rocquencourt
78150 - Le Chesnay
Tél. 954.90.20

Rapport de Recherche n° 35

octobre 1973
# PROJET DELTA : DESCRIPTION D'UN LANGAGE ALGORITHMIQUE A STRUCTURE DE BLOCS

F. Blaizot - P. Boullier

(présentés par B. LORHO)

## RESUME :

Ce papier décrit l'implémentation d'un langage à structure de blocs à l'aide d'un système de métacompilation, le système DELTA (Description des Langages et de leurs Traducteurs par Attributs). Cette description est faite à l'aide des attributs sémantiques définis par Knuth. Nous introduisons cependant ici des éléments nouveaux que nous appelons attributs de synchronisation. Ces attributs nous semblent plus adaptés à la description d'un processus de traduction que ne le sont les attributs de Knuth. Ceux-là conviennent en effet plus particulièrement à la définition sémantique d'un langage qu'à celle de son implémentation.

## ABSTRACT :

This paper describes the implementation of a block-structured language by means of a metacompiler system, referred to as DELTA (Description of Languages and Translators by Attributs). The language description is done with the help of semantic attributes defined by Knuth.

However, we have introduced the idea of synchronisation attributes as well, which seem to us to be more suitable than Knuth's attributes to describe the actual translation processes. The latter attributes are in fact more particularly adapted to the semantic definition of a language than to that of its implementation.
INTRODUCTION

Dans le cadre du projet DELTA* nous avons réalisé diverses implémentations
automatiques de traducteurs ainsi qu'il était annoncé dans [1]. Ce papier
présente la description d'un compilateur pour le "Small Langage" défini par
J.A. FELDMANN dans [2]. Ce langage avait pour nous les intérêts suivants

- C'est un langage à structure de blocs : Il nous est apparu souhaitable
de tester la validité des attributs sémantiques définis par KNUTH dans [3]
sur un exemple un peu plus probant que les nombres binaires [1]. Nous voulions
aussi nous rendre compte des problèmes nouveaux apportés par la description
sémantique de la structure de blocs.

- Ce langage est cependant suffisamment simple pour que cette réalisation,
qui n'avait qu'une valeur expérimentale, ne soit pas trop complexe. En fait
les facilités d'extension offertes par les attributs nous ont permis d'étendre
le "Small Langage" pour aboutir à un très large sous-ensemble d'algol, ce qui
permet d'utiliser actuellement le traducteur produit comme cutil pratique de
travail pour l'étude de l'optimisation et de la génération.

Cette réalisation avait pour but essentiel d'essayer de dégager les
concepts nécessaires pour le futur langage de description sémantique. Nous avons
choisi un langage suffisamment puissant, le PLI comme langage sémantique pour
cette réalisation car nous disposions de son compilateur.

<footnote>* DELTA : Description de Langages et de Traducteurs par Attributs.</footnote>
Réalisation

1. Compilateur classique :

Dans un compilateur classique dirigé par la syntaxe, la sémantique des non-terminaux de la syntaxe est portée par des variables globales. Ces variables globales se modifient lors de la compilation par l'exécution des différentes actions sémantiques.

Si l'enchaînement des actions sémantiques se lit directement dans la grammaire, les modifications des variables globales, accessibles par bon nombre d'actions, ne sont pas aussi claires. Cela est l'une des raisons qui rendent la mise au point et la lisibilité d'un compilateur classique ardues.

2. Attributs sémantiques :

La notion d'attributs sémantiques introduite par KNUTH [3] n'a pas cet inconvénient. En effet la sémantique d'un non-terminal de la grammaire, portée par un ou plusieurs attributs, ne s'exprime qu'en fonction de celle de ses ascendant et descendants immédiats. La portée d'un attribut est donc très locale. Cela permet d'obtenir la description sémantique d'un langage sous une forme très claire et facilement modifiable ce qui rend la mise au point du traducteur correspondant très aisée.

Par contre cette méthode a l'inconvénient d'être coûteuse en place. En effet à de simples transferts d'informations sémantiques dans l'arbre correspondent des identités d'attributs dans le programme d'évaluation sémantique. Ainsi une description sémantique partielle des expressions du "Small Langage" pourrait consister à associer à chaque non-terminal

- un attribut synthétisé TYPE (égal par exemple à 'B' si le type est bocléen et à 'I' si le type est entier)

- un attribut synthétisé GENRE ('R' pour référence, 'T' pour triplet, 'C' pour constante)

- un attribut synthétisé VALEUR (numéro de référence, numéro de triplet ou valeur de la constante).

Soit l'expression $(A + B) * C$. L'arbre associé est le suivant :
<figure><img src="image_4.png" /></figure>

Les valeurs associées aux trois attributs TYPE, GENRE et VALEUR passent sans modifications entre les noeuds

1 — 2 — 3 — 4

5 — 6 — 7

8 — 9 — 10 — 11

12 — 13

14 — 15 — 16

Ces 33 identités entre les 48 variables apparaîtront dans le programme d'évaluation.
Le nombre d'occurences d'attributs croît proportionnellement au nombre de
noeuds de l'arbre du programme source. Si le langage sémantique est le PL1
cela entraîne autant de déclarations explicites de variables que d'attributs
différents. On arrive donc très vite à un programme d'évaluation contenant
beaucoup d'identités entre attributs et par là même beaucoup de déclarations
correspondantes inutiles.

### 3. Approche choisie :

Pour notre réalisation nous avons essayé de conserver les avantages des
deux méthodes précédentes ; les informations sémantiques sont portées par des
variables globales et des attributs de "synchronisation" gouvernent les modifi-
cations de celles-ci. N'ayant pas de valeur associée, ces attributs n'ont pas
d'existence après le tri et ne contribuent donc pas à la taille du programme
d'évaluation produit.

Nous avons aussi cherché à minimiser l'occupation mémoire des données
du programme d'évaluation c'est-à-dire à ajuster exactement pour chaque
programme source la taille des variables globales. Par exemple nous utilisons
des tables globales pour faire suivre aux identificateurs du programme source
la structure de blocs de l'algol. Il est possible de déterminer exactement la
taille nécessaire de ces tables pour un programme source donné. Cela peut se
faire en simulant dans la description sémantique de l'algol, à l'aide
d'attributs de synchronisation, ce que l'on appellerait une passe dans un
compilateur classique.

### 4. Les différents attributs et les passes associées :

Le processus de traduction transforme un programme source algol en
"triplets". Chaque "triplet" est en général formé de deux champs opérandes
composés et d'un champ opérateur. Les champs opérandes contiennent le type,
le genre, le niveau de bloc, le niveau de procédure et le numéro de l'opérande.
Cela est bien sûr le cas le plus général. Certaines zones peuvent ne pas être
significatives (exemple : genre constante entraîne des niveaux non significa-
tifs). Le processus de traduction se déroule en quatre passes distinctes. Nous
allons détailler chacune de ces passes.

1. DEB (hérité) et FIN (synthétisé) sont les attributs qui déclenchent la première "passe". Ces deux attributs permettent d'affecter un numéro au premier et au dernier triplet qui seront associés à un non-terminal.
Par exemple pour l'expression arithmétique $A + B * C$ correspondant à l'arbre suivant :

<figure><img src="image_5.png" /></figure>

$TE_{10}$ aura pour numéro de triplet de début 1 et pour numéro de triplet de fin 1 c'est-à-dire un seul triplet, le triplet multiplication.

$TE_{11}$ aura pour numéro de triplet de début 1 et pour numéro de triplet de fin 2 c'est-à-dire un triplet multiplication et un triplet addition.

La numérotation des triplets se fait par incrémentation d'une variable globale CO. Ce n'est que lorsque l'on veut conserver le numéro de triplet de début ou de fin d'un non-terminal que l'attribut DEB ou FIN devient effectivement une variable et prend la valeur du CO que l'on veut conserver. Cela est utile par exemple sur la règle syntaxique permettant les instructions étiquetées.

$<S> = \partial I : <S>$

L'étiquette $\partial I$ sera caractérisée par le numéro du premier triplet du non-terminal $S_2$ (l'indice 2 indique la deuxième occurence de $<S>$ dans la règle).

Les attributs DEB et FIN contrôlent aussi le calcul (à travers les variables globales XNIV et XPROC) des profondeurs maximales (NIV et MAXPROC) de blocs et de procédures. Les valeurs maximales permettront de réserver exactement la taille nécessaire aux displays qui structureront la table des identificateurs au cours de la passe suivante.

2. La seconde passe est contrôlée par les attributs GAUCHE (hérité) et HAUT (synthétisé). Elle est initialisée dans la règle $<Z> = .<B>$. où GAUCHE(B) dépend de FIN(B).
Cette seconde passe utilise deux tables globales, les displays de
procédure et de bloc dont on connait exactement la profondeur, pour calculer
le nombre maximal d'identificateurs qui existeront simultanément au cours
de la compilation du texte source (donc la taille d'une table d'accès) et la
longueur de la table séquentielle où seront rangés ces identificateurs.

Ces attributs n'ont aucune valeur associée. Ils lient l'évolution
des variables globales dont les valeurs, lorsque HAUT(B) est défini, sont
les taille et longueur cherchées.

Exemple : Soit la règle `<B> = <H>` end où `<B>` signifie bloc et `<H>` tête de bloc.

- GAUCHE (H) va entrainer le calcul de la place nécessitée par les identificateurs éventuellement dans `<H>`. Cela n'aura lieu que si l'on cherche la place nécessaire aux identificateurs de `<B>` c'est-à-dire que GAUCHE (H) dépend de GAUCHE (B). Cette règle marque l'entrée dans un bloc. L'action sémantique à effectuer (erpiler les tailles avant l'entrée dans le bloc) se fait par une procédure globale (GTAILLE). La définition de GAUCHE (H) contient donc deux éléments

- la dépendance avec GAUCHE (B)

- l'appel de la procédure GTAILLE

- Inversement l'évaluation de HAUT (B) marque la sortie du bloc.
La définition de HAUT (B) contient donc

- la dépendance avec HAUT (H)

- l'appel d'une procédure globale (OTAILLE) qui restaure
les éléments sauvés lors de l'entrée dans le bloc.

3. La troisième passe est contrôlée par les attributs OPEN (hérité) et DEF (synthétisé). Ces attributs provoquent la mise en table des identificateurs dans des zones dont on connait exactement les longueurs puisqu'elles ont été calculées par la passe précédente. La réservation de ces zones figure explicitement dans la portion du programme d'évaluation qui correspond à la définition de l'attribut OPEN (B) de la règle `<Z> = .<B>`. Cet attribut OPEN (B) dépend donc de HAUT (B). Les mises en table se font, soit sur les règles syntaxiques décrivant les instructeurs de déclarations, soit sur la règle `<S> = 0I : <S>`. Les attributs OPEN et DEF n'existent donc que pour les non-terminaux figurant dans les règles concernées. La mise en table d'un bloc interne (règle `<U> = <E>`) n'est déclenchée que lorsque l'on veut générer les triplets correspondant à `<U>`. OPEN (B) (ou ouverture de bloc) dépend donc de l'attribut de génération de `<U>`, nous verrons qu'il s'agit de LOOK(U). L'attribut synthétisé DEF remonte l'information indiquant que la mise en table est effectuée (ou que les identificateurs du bloc sont définis) et que donc la génération pourra avoir lieu.
4. La quatrième passe ou passe de génération est contrôlée par les attributs LOOK (hérité) et CLOSE (synthétisé). La phase de génération du programme source débute lorsque la mise en table du bloc externe est terminée c'est-à-dire que dans la règle `<Z> = . <B>`. LOOK (B) dépend de DEF (B). L'attribut synthétisé CLOSE remonte l'information indiquant que pour le non-terminal concerné, la génération a eu lieu.

Dans la règle `<Z> = .<B>`, l'attribut CLOSE (Z) est défini à partir de CLOSE (B). Quand CLOSE (Z) est calculé (seul attribut de l'axiome), la compilation du programme source est terminée.

La phase de génération d'un bloc interne est déclenchée par la fin de la mise en table de ce bloc (1). Cette mise en table elle-même est déclenchée par la "demande" de génération du bloc (2).

Nous avons de façon plus précise les dépendances suivantes entre les attributs sur la règle `<U> =<B>` :

OPEN (E) dépend de LOOK (U) (2)

LOCK (B) dépend de DEF (E) (1)

CLOSE (U) dépend de CLOSE (B)

<figure><img src="image_6.png" /></figure>
5. Exemple : Compilation d'un programme source.

Ce programme source contient un certain nombre de concepts parmi les plus riches sémantiquement, a savoir :

- des déclarations

- une instruction étiquetée

- un bloc interne.

Les différentes planches représentent les passes successives dont chacune contient, au niveau du non-terminal <B>, l'amorce de la passe suivante.

Nous pouvons noter que les attributs ne descendent pas toujours dans l'arbre syntaxique jusqu'au niveau des feuilles. Ainsi, sur la planche numéro 2 nous notons qu'au niveau de la dérivation U → GTS (Unconditional statement → GoTo Statement) de l'instruction étiquetée, l'attribut GAUCHE (GTS) n'est pas défini. En effet GAUCHE demande le calcul de la longueur des tables et si <U> n'est pas un bloc, <U> ne peut contenir aucune déclaration ni aucune étiquette (les étiquettes sont prises en compte au niveau de <S> = ∂I : <S>).

La planche numéro 4 contient l'évolution de deux couples d'attributs. Elle montre en effet que la génération du bloc interne ne se fait qu'après la mise en table des identificateurs de ce bloc.
<figure><img src="image_7.png" /><figcaption>- 1 - Numérotation des triplets
Profondeur des displays</figcaption></figure>
<figure><img src="image_8.png" /></figure>
<figure><img src="image_9.png" /></figure>
<figure><img src="image_10.png" /></figure>
Si le processus de traduction que nous avons décrit nous permet de
compiler des programmes importants, la méthode employée se révèle insuffisante
du point de vue lisibilité. Il est certain qu'actuellement, vu les améliora-
tions apportées au système DELTA telles que la suppression des impasses et
des identités, nous utiliserions les attributs de façon plus pure (telle
que Knuth les a définis). Il est cependant intéressant de constater qu'ur
utilisateur peut, avec un tel système, doser l'efficacité et la lisibilité de
son processus de traduction comme il le veut.

Cette réalisation nous a convaincu de la nécessité de disposer, dans
le langage sémantique, de procédures standards et en particulier de
procédures de mise en table. Celles-ci constituent en effet la partie la
plus lourde de notre description. Le langage sémantique devra disposer aussi
de déclarations implicites ne serait-ce que peur éviter à l'utilisateur la
tâche fastidieuse qui consiste à déclarer les attributs.

Cette réalisation nous a permis de nous familiariser avec les besoins
en concepts sémantiques pour la définition d'un langage algorithmique. Nous
espérons que cette description nous aidera dans la définition du futur
langage sémantique du système DELTA.
Annexe :

Description du "Small Langage".
CALL JOVRIK;

#EF(0) DEF(H)

#CLOSE(0) LOOK(B)

#CALL FERNER;

4 <D> = BEGIN <FIND>,

#DEF(FIND) DEF(B)

ANIV=ANIV+1; NIV=MAX(NIV,XNIV);

#FIN(0) FIN(FIND)

ANIV=ANIV-1;

#GAUCHE(FIND) GAUCHE(B)

CALL STAILLE; HAUT(FIND)

CALL STAILLE; OPEN(FIND)

CALL JOVRIK; OPEN(FIND)

#EF(0) DEF(FIND)

#LAVR(FIND) LOOK(B)

#CLOSE(0) CLOSE(FIND)

#CALL FERNER;

5 <D> = <H> #; <FIND>,

#DEF(H) DEF(B)

ANIV=ANIV+1; NIV=MAX(NIV,XNIV);

#DEF(FIND) FIN(H)

#FIN(0) FIN(FIND)

ANIV=ANIV-1;

#GAUCHE(H) GAUCHE(B)

CALL STAILLE; HAUT(FIND)

#GAUCHE(FIND) HAUT(FIND)

#HAUT(0) HAUT(FIND)

#OPEN(H) OPEN(B)

CALL JOVRIK; OPEN(FIND)

#OPEN(FIND) DEF(H)

#LAVR(FIND) DEF(FIND)

#LAVR(FIND) LOOK(B)

#CLOSE(B) CLOSE(FIND)

#CLOSE(B) CLOSE(FIND)

#CALL FERNER;

3 <H> = BEGIN <D> ;

#DEF(0) DEF(H)

#FIN(H) FIN(0)

#GAUCHE(0) GAUCHE(H)

#HAUT(H) HAUT(0)

#OPEN(0) OPEN(H)

#DEF(0) DEF(0)

/ <H> = <M> #; <D> ;

#DEF(H) DEF(H)

#FIN(H) FIN(H)

#GAUCHE(H) GAUCHE(H)

#GAUCHE(0) HAUT(H)

#HAUT(H) HAUT(0)

#OPEN(H) OPEN(H)

#OPEN(0) DEF(H)

#DEF(H) DEF(0)

#DEF(H) DEF(0)

8 <D> = <IA> <ILM> ;

#DEF(0) DEF(0)

#FIN(H) FIN(H)

#GAUCHE(0) GAUCHE(0)

#HAUT(0) HAUT(0)

#OPEN(0) OPEN(0)
```pascal
# PPLN(LA)      DEF(LA)
# PPLN(LA)      DEF(LA)
9 <U> = <IA> ARRAY <LUTAB> ;
        #DEF(LUTAB)
        #PPLN(LA)
        #GAUGE(LUTAB)
        #AUTO(LA)
        #OPEN(LA)
        #OPEN(LUTAB)
        #DEF(LA)
        #DEF(LUTAB)
10 <U> = <DEPKCL> ;
        #DEF(DEPKCL)
        ANIV=ANIV+1;NIV=MAX(NIV,XNIV); XPRCL=APRCL+1;
        PAKROL=PAX(MAXPRCL,APRCL);
        #PPLN(LA)
        ANIV=ANIV+1; XPRCL=APRCL+1;
        #GAUGE(DEPKCL)
        #AUTO(LA)
        #OPEN(DEPKCL)
        #DEF(LA)
        #DEF(DEPKCL)
11 <LUTAB> = <LUTAB> ; #1 ( <LUPBD> ) ;
        #DEF(LUTAB)
        #DEF(LUTAB)
        #FIN(LUTAB)
        #DEF(LUTAB)
        LQ=LR+1;STX=AM;
        #GAUGE(LUTAB)
        #AUTO(LUTAB)
        CALL AUTO('TEXT(01)');
        #OPEN(LUTAB)
        #OPEN(LUTAB)
        #DEF(LUTAB)
        STX=AM;
        #OPEN(LUPBD)
        CLOSE(LUPBD)
        PUT EDIT(LQ,TYPE,11,'ALBC',1A,XPRCL,NIVBLC,NUME0
                ,LQ=LR+1)(R(E))=LQ=LR+1;XH=STXH;
        #DEF(LUPBD)
        GENRE=1A; CALL DEFINK('TEXT(01)');XH=STXH;
12 <LUTAB> = 01 ( <LUPBD> ) ;
        #DEF(LUPBD)
        DEF(LUTAB)
        STX=AM;LQ=LR+1;
        #FIN(LUTAB)
        XH=STXH;
        #AUTO(LUTAB)
        GAUGE(LUTAB)
        CALL AUTO('TEXT(01)');
        #LOCK(LUPBD)
        OPEN(LUTAB)
        STX=AM;
        #OPEN(LUPBD)
        CLOSE(LUPBD)
        PUT EDIT(LQ,TYPE,11,'ALBC',1A,XPRCL,NIVBLC,NUME0
                ,LQ=LR+1)(R(E))=LQ=LR+1;XH=STXH;
        #DEF(LUPBD)
        GENRE=1A; CALL DEFINK('TEXT(01)');XH=STXH;
13 <LUPBD> = <LUPBD> , <PCL> ;
        #DEF(LUPBD)
        #DEF(LUPBD)
        #FIN(LUPBD)
        #LOCK(LUPBD)
        #LOCK(LUPBD)
        #OPEN(LUPBD)
        #OPEN(LUPBD)
        #DEF(LUPBD)
        CLOSE(LUPBD)
        DEF(LUPBD)
        FIN(LUPBD)
        LO=(LUPBD)
        CLOSE(LUPBD)
        OPEN(LUPBD)
        DEF(LUPBD)
        CLOSE(LUPBD)
```
18 <IUP> = #i,
#AUC(IUP)      DEC(IUP)
#RAU(IUP)      GAULHE(IUP)
#SEM(IUP)      USEM(IUP)
N=U;
#ECH(IUP)      OPEN(IUP)
19 <IUP> = ( <LFF> ) #, <PS> #i;
#DEC(PS)      DEC(IUP)
#FIN(IUP)      FIN(PS)
#GAUC(IFF)     GAUCHE(FF)
#AUT(IUP)      HAUI(LPF)
#DEF(IFF)      USEM(IUP)
#SEM(IFF)      SEM(LPF)
#JPEN(LPF)     OPEN(IUP)
#JPEN(PS)      DEF(LPF)
#DEF(IUP)      DEF(PS)
20 <LFF> = #1;
#AUT(LPF)      GAULHE(LPF)
CALL NACI2('IEXT(01)');
USEM(LPF)
N=1;
#DEF(LPF)      OPEN(LPF)
GENRE='I'; CALL PUTNUM('TEXT(01)');
21 <LFF> = <LFF> , #1;
#GAUC=(LFF)    GAULHE(LFF)
#AUT(LPF)      HAUI(LPF)
CALL NACI2('IEXT(01)');
USEM(LPF)      USEM(LPF)
#SEM(LPF)      SEM(LPF)
N=N+1;
#JPEN(LPF)     OPEN(LPF)
#DEF(LPF)      DEF(LPF)
GENRE='I'; CALL PUTNUM('TEXT(01)');
22 <PS> = <SPE> <LPS>,
#DEC(LPS)      DEC(PS)
#FIN(PS)       FIN(LPS)
#OPEN(PS)      OPEN(PS)
#DEF(LPS)      DEF(PS)
#DEF(PS)       DEF(LPS)
23 <PS> = <PS> #; <SPE> <LPS> ;
#DEC(PS)      DEC(PS)
#FIN(PS)      FIN(PS)
#JPEN(PS)     OPEN(PS)
#JPEN(PSF)    DEF(PS)
#JPEN(LPS)    DEF(PS)
#DEF(PS)      DEF(LPS)
24 <LPS> = <LP>,
#FIN(LPS)      DEC(LPS)
#JPEN(VP)      CD=CD+1;
#DEF(LPS)      OPEN(LPS)
#DEF(VP)       DEF(VP)
25 <LPS> = <LPS>, <VP>,
#DEC(LPS)      DEC(LPS)
#FIN(LPS)      FIN(LPS)
CD=CD+1;
#JPEN(LPS)    OPEN(LPS)
#JPEN(VP)      DEF(LPS)
#DEF(LPS)      DEF(VP)
26 <VP> = #1;
```pascal
#DEF(VP)          OPEN(VP)
                      N1:=CALL_ALDP('TEXT(@1)');

27 <VP> = @1 ( <LSTAN> ) ;
               #OPEN(LSTAN)      OPEN(VP)
               #DEF(VP)          DEF(LSTAN)
               CALL_ALDP('TEXT(@1)');

28 <LSTAN> = * ;
               #DEF(LSTAN)      OPEN(LSTAN)
                                  N1:=1;

29 <LSTAN> = <LSTAN> , * ;
               #DEF(LSTAN)      DEF(LSTAN)
                                  N1:=N1+1;
               #OPEN(LSTAN)      OPEN(LSTAN)

30 <TA> = INTEGER ;
               #DEF(TA)        OPEN(TA)
                                   TYPE:=11;

31 <TA> = DOULEAN ;
               #DEF(TA)        OPEN(TA)
                                   TYPE:=10;

32 <TA> = LABEL ;
               #DEF(TA)        OPEN(TA)
                                   TYPE:=10;

33 <SPE> = INTEGER ;
               #DEF(SPE)        OPEN(SPE)
                                   TYPE:=11; GENKE='K1';

34 <SPE> = DOULEAN ;
               #DEF(SPE)        OPEN(SPE)
                                   TYPE:=10; GENKE='K1';

35 <SPE> = LABEL ;
               #DEF(SPE)        OPEN(SPE)
                                   TYPE:=11; GENKE='K1';

36 <SPE> = INTEGER ARRAY ;
               #DEF(SPE)        OPEN(SPE)
                                   TYPE:=11; GENKE='A1';

37 <SPE> = DOULEAN ARRAY ;
               #DEF(SPE)        OPEN(SPE)
                                   TYPE:=10; GENKE='A1';

38 <SPE> = LABEL ARRAY ;
               #DEF(SPE)        OPEN(SPE)
                                   TYPE:=11; GENKE='A1';

39 <SPE> = PROCEDURE ;
               #DEF(SPE)        OPEN(SPE)
                                   TYPE:=11; GENKE='F1';

40 <SPE> = INTEGER PROCEDURE ;
               #DEF(SPE)        OPEN(SPE)
                                   TYPE:=11; GENKE='F1';

41 <SPE> = DOULEAN PROCEDURE ;
               #DEF(SPE)        OPEN(SPE)
                                   TYPE:=11; GENKE='F1';

42 <SPE> = LABEL PROCEDURE ;
               #DEF(SPE)        OPEN(SPE)
                                   TYPE:=11; GENKE='F1';

43 <ILA> = @1 ;
               #FIN(ILA)        DEFTILA
                                   CD:=CD+1;
               #DEF(ILA)        OPEN(ILA)
                                   CALL_ALDP('TEXT(@1)');
               #HAUT(ILA)       GAUCHE(ILA)
               CALL_PANT2('TEXT(@1)');

44 <TLA> = <ILA> , @1 ;
```
```
#DEF(ILA')      DEB(ILA')
#FIN(ILA')      FIN(ILA')
#DEF(ILA)       DEB(ILA')
#GAUCHE(TLA')   GAULHE(ILA')
#HAUT(ILA')     HAUT(ILA')
CALL MAJTE2('TEXT(01)');
#OPEN(TLA')     OPEN(TLA)
END;

45 <FINB> = <S>      DEB(FIND)
                      FIN(S)
                      GAULHE(FIND)
                      HAUT(S)
                      OPEN(FIND)
                      DEP(S)
                      LOOK(FIND)
                      #CLOSE(S)

46 <FINB> = <S>      DEB(FIND)
                      FIN(S)
                      FIN(FIND)
                      GAUCHE(FIND)
                      HAUT(S)
                      HAUT(FIND)
                      OPEN(FIND)
                      DEP(S)
                      DEP(FIND)
                      LOOK(FIND)
                      CLOSE(S)
                      #CLOSE(FIND)

47 <A> = <VAK>      DEB(FIND)
                      FIN(EX)
                      FIN(VAK)
                      CU=CU+1;XH=KH-2;
                      LOOK(A)
                      CLOSE(EX)
                      CLOSE(VAK)

48 <S> = <U>       CALL GENAF;
                      #CLOSE(VAK)

49 <S> = <POUK>    DEB(L)
                      FIN(S)
                      GAUCHE;
                      HAUT(S)
                      HAUT(FIND)
                      OPEN(S)
                      DEP(L)
                      LOOK(S)
                      CLOSE(L)

50 <S> = <U>       DEB(PUK)
                      FIN(PUK)
                      GAUCHE(S)
                      HAUT(PUK)
                      OPEN(S)
                      DEP(PUK)
                      LOOK(S)
                      CLOSE(PUK)
```
DEB(S)
#FIN(S)
#GAUCHE(U)
#HAUT(S)
#DEF(S)
#LOOK(U)
#CLOSE(S)

DEB(S)
GAUCHE(S)
LOOK(S)
CLOSE(U)

51 <S> = #; ;

FIN(S)
#AUT(S)
#CLOSE(S)
#DEF(S)

DEB(S)
GAUCHE(S)
LOOK(S)
OPEN(S)

52 <S> = RETURN;

FIN(U)
#AUT(U)
#CLOSE(U)

DEB(U)
GAUCHE(U)
LOOK(U)

PUT LIST((PAS DE VALEUR RETOURNE POUR UNE FONCTION «))
ELSE PUT EDIT((U),KEIP(),(K(),); CU=CU+1;

#FIN(EA)
#FIN(U)

DEB(U)
FINTEA)
CU=CU+1; XH=XH=1;

#AUT(U)
#UK(U)

GAUCHE(U)
LOOK(U)
CLOSE(EA)

#CLOSE(U)

IF TYP(PAUK(XPROCL)) = TYP(P(XH)) THEN
PUT LIST((TYPE DE LA VALEUR RETOURNE INCORRECT «));
ELSE PUT EDIT((U),TYP(P(XH),KEIP(),GEN(XH),PKOCC(XH),NIVV(XH),NUMM(XH))(K(F)));
XH=XH-1; CU=CU+1;

54 <S> = 61 ;

FIN(S)
#AUT(S)
#DEF(S)
#CLOSE(S)

DEB(S)
CU=CU+1;

GAUCHE(S)
OPEN(S)
LOOK(S)

I=CHEKHEK((TEA(91))«U);
IF ((I=0))((GEN(I) =IP(I))=(IP(I) = « ))THEN PUT LIST((I'IDENTIFICATEUR),
'TEXT(I))=TEST INCORRECT «);
ELSE PUT EDIT((U),TYP(I),CALL((GEN(I)),NIVPRBC(I),NIV(I),NUM(I))(K(F)));
CU=CU+1;

#EDE(VAL)
#FIN(3)

DEB(S)
FINTVAI)
XH=XH=1;

#SLIM(VAL)
#LOOK(VAL)
#CLOSE(S)

IF TYP(XH) = « ' THEN PUT LIST((NUM DE PROCEDURE INCORRECT «))
XH=XH-1;

#AUT(S)
#DEF(S)

GAUCHE(S)
OPEN(S)

DEB(S)

DEB(S)=CU;

DEB(S)=CD;

FIN(S)
#GAUCHE(S)
#HAUT(S)

DEB(S)

DEB(S)

FIN(S)
#GAUCHE(S)
#HAUT(S)
```
OLL EDIT(LPD0) FIXED ;DEB(LPD0)=DEB(EA);CL=LU+2;DCL FIN(VAK) FIXED
FIN(VAK)=CL=1;XH=1;
#11R(POK)
#AUCHE(LPD) GAUCHE(PD0K)
#RAU(LPD) MAU(LPD)
#OPEN(LPD0) OPEN(PD0K)
#DEF(POK) DEF(LPD0)
#LOOK(EA) LOOK(PD0K)
#LOOK(VAK) CLOSE(EA)

PUT EDIT(LCD, '1'G8T8T9'T'00,00,
FIN(VAK))(K(F));CL=LG+1;
#LOOK(LPD0) CLOSE(VAK)
PUT EDIT(LCD,1)PP(XH),IKE (1)GEN(XH),PROCL(XH),NIVV(XH),NUMM(XH))(K(F));
IF GEN(XH)=11 THEN CALL PUISEMIN(XH),TYP(P(XH),S),0,0,DEB(VAK));
IF TYP(XH)=11 TYP(XH-1)=11 THEN
PUT LIST(VARIABLE CONTROLLE DU VALEUR INITIALE INCORRECTE):
CLOSE PUT EDIT(LCD+1)PP(XH),TYP(XH-1),GEN(XH),PROCL(XH),NIVV(XH),
RUN(XH),GEN(XH-1),PROCL(XH-1),NIVV(XH-1),NUMM(XH-1))(K(E));CL=CD+2,
AEXM=2;CALL PUISEM(TYP(XH+2),GEN(XH+2),PROCL(XH+2),NIVV(XH+2),NUMM(XH+2));
#CLOSE(PD0K) CLOSE(LPD0)
#USE(VAK)

63 <LPD> = STEP <EA> OUT <EA> DB <S> ;
"DEB(EA)
LJ=CL+1;DCL DEB(EA) FIXED ;DEB(EA)=CD;
#DEB(EA)
FIN(EA)
CL=CL+1;DCL FIN(EA) FIXED ;FIN(EA)=CD;
FDEB(S)
FIN(EA)
CL=CL+4;
#FIN(LPD0)
FIN(S)
CL=CL+3; DCL FIN(LPD0) FIXED ; XH=XH-3; FIN(LPD0)=CL;
#AUCHE(S) GAUCHE(LPD0)
#RAU(LPD0) MAU(S)
#OPEN(LPD0) OPEN(LPD0)
#DEF(LPD0) DEF(S)
#LOOK(EA) LOOK(LPD0)
#LOOK(EA)
PUT EDIT(LCD, '1'G8T8T9'T'00,00,FIN(EA))(K(F));CL=CL+1;
#AUCHE(S) GAUCHE(LPD0)
#RAU(LPD0) MAU(S)
#OPEN(LPD0) OPEN(LPD0)
#DEF(S) DEF(S)
#LOOK(EA)
PUT EDIT(LCD,1)PP(XH),IKE (1)GEN(XH),PROCL(XH),NIVV(XH),NUMM(XH))(K(F));
CL=CL+1;TYP(XH)=11 THEN CALL PUISEMIN(XH),TYP(XH),S),0,0,DEB(EA));
#LOOK(S)
CALL GEN(PD0K(XH,XH-2),XH-1);
PUT EDIT(LCD,1)PP(XH),11,CL>2, '1'GEN(XH),PROCL(XH),NIVV(XH),NUMM(XH),S),0,0,0)
(K(E));
PUT EDIT(LCD+1)PP(XH),11,IF '1'IF '1'G8T8T9'T'00,00,FIN(LPD0)
(K(E));(CL=CL+2;
#CLOSE(LPD0)
CLOSE(S)
AEXM=2;CALL GEN(PD0K(XH,XH+1),XH+1,);
PUT EDIT(LCD,1)PP(XH),TYP(XH+1),S, '1'GEN(XH),PROCL(XH),NIVV(XH),NUMM(XH),
GEN(XH+1),PROCL(XH+1),NIVV(XH+1),NUMM(XH+1))(K(E));
XH=XH-1;
64 <LPD> = WHILE
<ED> TO <S> ;
"DEB(EA)
FIN(EA)
CL=CL+1;DCL DEB(EA) FIXED ;FIN(EA)=CD;
#DEB(S)
FIN(S)
CL=CL+1;XH=XH-2;
#FIN(LPD0)
FIN(S)
CL=CL+1;DCL FIN(S) FIXED ;FIN(S)=CL;
#AUCHE(S) GAUCHE(LPD0)
#RAU(LPD0) MAU(S)
#OPEN(S) OPEN(LPD0)
#DEF(LPD0) DEF(S)
```
```pascal
#LOCK(ED)      LOOK(LPD)
#LOCK(1S)      CLOSE(ED)
PUT EDIT(LD,1S,1), 'IF 1, GEN(XH),PROJCC(XH),NIVV(XH),NUMM(XH),
               T(1),U,0,-1,N(S)),(K(E))=CO+1;

#X=10-23
#CLLUS(LPD)   CLOSE(1S)

#USEM(ED)
60 <LTS> = GOTO <VAK>,
       #DEF(VAK)      DEF(GTS,
       #FIN(LTS)      FIN(VAK)
       CD=CO+1,X=1,XH=1-1)
       #LOOK(VAK)     LOOK(GTS)
       #CLOSE(LTS)    CLOSE(VAK)
       CALL GENBGT0)

#USEM(VAK)
66 <EX> = <EA> ;
       #DEF(EA)      DEF(EX)
       #FIN(LX)      FIN(EA)
       #LOOK(EA)     LOOK(EX)
       #CLLUS(EX)    CLOSE(EA)

67 <EX> = <ED> ;
       #DEF(LD)      DEF(LX)
       #FIN(LX)      FIN(LX)
       #USEM(ED)     LOOK(EX)
       #LOOK(ED)     LOOK(EX)
       #CLLUS(ED)    CLOSE(ED)

68 <IS> = <IC> <U>;
       #DEF(IC)      DEF(IS)
       #DEF(U)       FIN(IC)
       U=CO+1;

#FIN(IC)
69 <IC> = IF <L> THEN ;
       #DEF(LD)      DEF(IC)
       #FIN(IC)      FIN(ED)
       #USEM(ED)     LOOK(IC)
       #LOOK(LS)     LOOK(IC)
       #CLLUS(IC)    CLOSE(IC)

70 <EA> = <EA> + <IE> ;
       #DEF(EA')    DEF(EA')
       #DEF(IE)      FIN(EA')
       #FIN(EA)     FIN(IE)
       #LOCK(EA')   LOOK(EA')
       #LOOK(IE)     CLOSE(EA')
       #CLLUSEA')   CLOSE(IE)
       CALL GENAMITH(1+ '))

71 <EA> = <EA> - <IE> ;
       #DEF(EA')   DEF(EA)
```
72 <EA> = + <IE> ;
#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

73 <EA> = - <IE> ;
#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

IF IYPP(XH) = 11 THEN PUT LIST(' EXPRESSION ERRUNNEE .1);
CLOSE PUT EDIT(LD, IYPP(XH), 'COMP', GEN(XH), PKOCL(XH), NIVV(XH), NUMM(XH))(K(F)));
XH=1; CALL PUISEM(IYPP(XH+1), 111, 0, 0, CO);
Ld=Co+1;

74 <EA> = <IE> ;
#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

75 <IE> = <IE> * <F> ;
#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

76 <IE> = <IE> / <F> ;
#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

77 <IE> = <IE> * <F> ;
#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

78 <F> = <P> ;
#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

79 <F> = <F> ** <P> ;
#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)

#EED(IE)
#FIN(IE)
#LOOK(IE)
#CLOSE(IE)
CO=CO+1;AN=XH-1;
#LOOK(F)
#LOOK(F)
#CLOSE(F)
#CLOSE(F)
CALL GENAKITH(*** );

80 <PD > = ( <EA> ) ;
#EDE(EA)
#FIN(F)
#LOOK(EA)
#CLOSE(F)

DEB(F)
FIN(EA)
LOOK(F)
CLOSE(EA)
IF IYP(P(XH) =1) THEN PUT LIST('EXPRESSION EKKONEE')

81 <PD > = ABCDEF;
#FIN(F)
#CLOSE(F)

DEB(F)
CALL HAVIEUKXH;
LOOK(F)
CALL .ISEM(111,1'0,0,U,TEXT(@CONST));

82 <ED> = <ID> ;
#EDE(ID)
#FIN(ID)
#CLOSE(ID)
#LOOK(ID)
#USEM(ID)

DEB(ED)
FIN(ID)
CLOSE(ID)
LOOK(ED)
USEM(ED)
SEM(ID)

83 <ED> = <ID> <ID> <ID> ;
#EDE(ID)
#CALL DEB(ID) FIXED;
DEB(ID) =CO;

#EDE(ID)
#FIN(ID)
#X=XM=3;
#SEM(ED)

USEM(ED)
CALL PUISEM('B',1'T',0,0,DEB(IC));

#LOOK(ID)
#USEM(ID)
#X=XM=3;
#SEM(ID)

LOOK(ED)
CLOSE(ID)
SEM(ID)

#LOOK(ID)
#USEM(ID)
#X=XM=3;
#SEM(ID)

#LOOK(ED)
#CLOSE(ID)

X=XM=2;CALL PUISEM('B',1'T',0,0,DEB(IC));

84 <ID> = <FD> ;
#EDE(FD)
#FIN(FD)
#CLOSE(FD)
#LOOK(FD)
#USEM(FD)
#SEM(FD)

DEB(FD)
FIN(FD)
CLOSE(FD)
LOOK(FD)
USEM(FD)
SEM(FD)

85 <ID> = <ID> n1 <FD> ;
#EDE(FD)
#FIN(FD)
#X=XM=1;
#LOOK(FD)
#CLOSE(FD)

DEB(FD)
FIN(FD)
CLOSE(FD)
LOOK(FD)
CLOSE(FD)
```
# USEL(FB)
CLOSE(FB)
/* CLOSE(FB) */ CALL GENBODL('OK');
#(FB)
SEM(FB)
XH=AH-2;
CALL PUTSEM('B',1,'00,FIN(PB));
#USEM(FB)
USEM(FB)
#LSE(FB)
SEM(FB)

86 <FB> = <PO> ;

#LSE(FB)
FIN(FB)
CLOSE(FB)
#LCK(FB)
LOOK(FB)
USEM(FB)
SEM(FB)

3/ <FB> = <PO> 0
<PO> ;

#LSE(FB)
FIN(FB)
#LSE(FB)
FIN(FB)

#FIN(FB)
CALL FIN(PB) FIXED ; FIN(PB)=CD;

#LCK(FB)
LOOK(FB)
#LCK(FB)
CLOSE(FB)
#LCK(FB)
CLOSE(FB)

#LSE(FB)
CALL GENBODL('AND');

#USEM(FB)
USEM(FB)
SEM(FB)

88 <PO> = <SD> ;

#LSE(SD)
FIN(SD)
CLOSE(SD)
#LCK(SD)
LOOK(SD)
USEM(SD)
SEM(SD)

89 <SD> = ( <ED> ) ;

#LSE(ED)
FIN(ED)
CLOSE(ED)
#LCK(ED)
LOOK(ED)
USEM(ED)
SEM(ED)

90 <PO> = <VAK> ;

#LSE(VAK)
FIN(VAK)
CLOSE(VAK)
#LCK(VAK)
LOOK(VAK)
#LSE(VAK)

91 <VAK> = 81 ;

#FIN(VAK)
/* LSE(VAK) */
CALL HALIFURAN;
#LCK(VAK)
LOOK(VAK)
CALL SEMVAR('TEXT(81)');
#SEM(VAK)
USEM(VAK)
CALL SEMVAR('TEXT(@1)');

92 <VAK> = <VAI> ;

#LSE(VAI)
FIN(VAI)
CLOSE(VAI)
#LCK(VAI)
LOOK(VAI)
```
```
#LLOSL(VAI)      CLOSE(VAI)
#LSE(VAI)        USEM(VAI)
#LSE(VAX)        SEM(VAX)
93 <VAI> = 01 ( <LI> ) ;
        #LSE(LI)      DES(VAI)
        ALL DES(LI)+FIXED ;DEB(LI)=CO;XPIMB=XPIMB+1;PIMB(XPIMB)=XH;
        #FIN(VAI)      FIN(LI)
        CO=CO+XH=PIMB(XPIMB)+1;XH=PIMB(XPIMB)+1;XPIMB=XPIMB=1;
        #LOOK(LI)      LOOK(VAI)
        APIMB=XPIMB+1;PIMB(XPIMB)=XH;
        INPTYP(XH=IMB)=CHEMCHER(TEXT(@1),@0);
        #LLOSE(VAI)     CLOSE(LI)
        USEM(VAI)      CALL GENIAB('TEXT(@1)');
        CALL PUISEM('I',T,0,0,0,DEB(LI));
94 <LI> - <LI> , <EA> ;
        #LSE(LI)      DES(LI)
        #LSE(EA)      FIN(LI)
        #FIN(LI)      FIN(EA)
        #LOOK(=1)      LOOK(LI)
        #LOOK(EA)      CLOSE(LI)
        #LLOSE(LI)     CLOSE(EA)
95 <LI> = <EA> ;
        #LSE(EA)      DES(LI)
        #FIN(LI)      FIN(EA)
        #LOOK(EA)      LOOK(LI)
        #LLOSE(LI)     CLOSE(EA)
96 <SD> = <VAR> ;
        #LSE(VAK)      DES(SB)
        #FIN(SB)       FIN(VAK)
        #LCK(VAK)      LOOK(SB)
        #LLOSE(SB)      CLOSE(VAK)
        #SEM(VAK)      USEM(SB)
        #SEM(SB)       SEM(VAK)
97 <PB> = <SD> ;
        #LSE(SB)      DES(PB)
        #FIN(PB)      CALL FIN(SB) FIXED LOOK(PB) CLOSE(SB)
        #LOOK(SB)      IF (TYPE(XH)='B' THEN PUT LIST('EXPRESSION ERRKUNEER')ELSE
        XH=AP=1;
        CALL PUISEM('B',1,1,0,0,0,CO=CO+1;
        #SEM(SB)      USEM(PB)
        #SEM(PB)      SEM(SB)
        XH=XH=1;
        CALL PUISEM('B',1,1,0,0,FIN(SB));
98 <SD> = TRUE ;
        #FIN(SB)      DES(SB)
        CALL HAUTEURAN;
        #LLOSE(SB)     LOOK(SB)
        #SEM(SB)       CALL PUISEM('B',1,'C',0,0,0,1);
        #SEM(SB)       USEM(SB)
        CALL PUISEM('B',1,'C',0,0,0,1);
99 <SD> = FALSE ;
        #FIN(SB)      DES(SB)
        CALL HAUTEURAN;
        #LLOSE(SB)     LOOK(SB)
        CALL PUISEM('B',1,'C',0,0,0,0);
```
Bibliographie

[1] Laurent BLAIZOT
"DELTA" (Cahier LABORIA)

[2] J.A. FELDMAN
"A FORMAL SEMANTICS FOR COMPUTER LANGUAGES AND ITS APPLICATION IN
A COMPILER-COMPILER" (C.A.C.M. - JV. 1966)

[3] D.E. KNUTH
"SEMANTICS OF CONTEXT-FREE LANGUAGES"
(Mathematical Systems Theory 2.1968)

[4] D.E. KNUTH
"EXAMPLES OF FORMAL SEMANTICS"
(Symposium on Semantics of algorithmic languages. 1970. SPRINGER VERLA

[5] J.L. BOUCHENEZ
"DELTA: un système d'écriture automatique de traducteurs"
(Cahier LABORIA)