programmation procédurale transformations c. transformation définition quelques transformations...

Programmation procéduraleTransformations

C. Transformation

Définition

Quelques transformations remarquables

Bohm et Jacoppini : B --> D

Méthode par automate : B --> D

Arsac : B --> REn Ramshaw : B-->REn

Williams and Chen :B --> D

R --> B ( procédé sémantique)


� Introduction

• Une transformation de programmes est une modification source à source.

• Une transformation doit être compréhensible, assurer l'équivalence, précise pour permettre une automatisation.On distingue :- les transformations syntaxiques : dépendent uniquement de la forme du programme.- les transformations sémantiques : tiennent compte de la signification du programme (éliminer les test inutile, détecter et éliminer les parties inaccessibles d'un programme, ...)

• Toutes les transformations que nous développons ici sont fonctionnelles.


� Introduction : Pourquoi transformer des algorithmes ?

• Chaque type de construction représente un mode de pensée.Donc, un programmeur conçoit son algorithme à sa façon dans un formalisme de son choix. Puis, il l'exprime dans une forme structurée dans le but de le rendre plus lisible et plus facile à le mettre au point.

• Domaines d'utilisation :. Synthèse des programmes

(Partir d'une spécification mathématique et arriver par une série de transformations à un programme) .Structuration d'algorithmes


� Introduction

• Toutes les structures que nous avons présentées ( des langages procéduraux) peuvent être répartie en deux catégories : ceux qui utilisent des saut explicites ( avec goto, exit) et ceux qui utilisent des saut implicites( D, BJ,..). Les premières se transforment trivialement vers les B, les second de la même façon vers les D. Il est donc intéressant d'étudier le passage entre les B et les D algorithmes.

Deux articles contradictoires méritent d'être évoqués :- DIJKSTRA(1968) critique l'utilisation des GOTO" L'instruction GOTO a des effets désastreux"- KNUTH (1974) "Programmation structurée avec GOTO". Le GOTO pourrait être un outil efficace s'il est bien utilisé.


� Bohm et Jaccopinni (1966)


� Technique par automate

• Pour tout B-algorithme, on associe un automate et on donne son algorithme correspondant. Chaque étiquette dans le B-algorithme représente un état dans l'automate. Quelques étiquettes additionnels sont nécessaires au niveau du B-algorithme pour réaliser la transformation.


� Technique par automate• Soit le B-algorithme suivant :

ab

E1 cdIF t1 GOTO E2x

E3 IF t2 GOTO E4zGOTO E1

E2 rsuGOTO E3uv

E4 xyz


� Technique par automate ( Etape 1 : Réecriture )

• Étiqueter la première instruction.

• Étiqueter aussi toute instruction conditionnel contenue dans le B-algorithme.

• Si plusieurs actions atomiques se suivent et ne sont pas étiquetées, les rassembler en une séquence.

• En plus, pour chaque état(Label), associer la condition correspondante par la construction d'une table de correspondance(COND) entre les états et les conditions.


� Technique par automate ( Etape 1 : Réecriture )

• $0 [a, b]E1 [c, d]$1 IF t1 GOTO E2

[x]E3 IF t2 GOTO E4

[z]GOTO E1

E2 [r, s, u]GOTO E3[u, v]

E4 [x, y, z]


� Technique par automate

• Table Cond :

$0 TrueE1 True$1 t1E3 t2E2 TrueE4 True


� Technique par automate ( Etape 2 : matrice de transition )

• Construire la matrice de transition à partir du B-algorithme.

• Pour chaque état S, si la condition associée(dans COND) est vrai c'est MAT(S, True) qui est considéré sinon c'est MAT(S, False).

• Considérer veut dire l'action avant le symbole avant --> est exécutée, puis aller à l'état figurant après '->'.

• Remarquer que la séquence [u, v] is supprimée comme elle n'est pas accessible.


� Technique par automate ( Etape 3 : D-algorithme )

• Donner le D-algorithme correspondant.

• On utilise "IF THEN ELSE" en cascade.

• Chaque "if statement" correspond à une ligne de la matrice.

• Si un état à une valeur toujours vrai dans COND, donner simplement les actions correspondantes sil elles existent suivie par la modification de l'état courant.


� Technique par automate ( Etape 3 : D-algorithme )

• Si un état a une condition t, donner un choix entre les deux colonnes de la matrice selon la valeur logique de t.

Par exemple, à la ligne E3 de la matrice on associe l'alternative suivante :

If Cond(E3) :State := E4

Else z ; State := E1

Endif


� Technique par automate• Pour l'exemple, on obtient : (State est une variable. F désigne l'état

finale ){ Initialisation }State := $0WHILE ( State # F ) : IF State = $0 :

a; b; State := E1 ELSE

IF State = E1 : c; d; State := $1

ELSE IF State = $1 :

IF t1 :State := E2

ELSE x; State := E3 ENDIF


� Technique par automate ELSE

IF State = E2 :r; s, u; State := E3

ELSEIF State = E3 : IF t2 : State := E4

ELSE z; State := E1 ENDIFELSE IF State = E4 : x; y; z; State := F

ENDIFENDIF

ENDIF ENDIF

ENDIF ENDIFENDWHILE


� Arsac REn-->D (1977)

• La technique revient à poser le programme sous la forme d'un système de d'équations où les inconnus sont les étiquettes puis à le résoudre.

• Le programme en sortie est un programme RE-n ( exit multi-niveaux)


• Arsac REn-->D (1977)

• Méthode :

a) Etiquetter la première instruction.

b) Introduire les "sinon" :

c) Mise en équation :d) Résoudre le système :

d1)Substitution ( élimination d'une variable) , revient à substituer les variables non récursives.

d2) Récursifier / Dérécursifier


� Arsac REn-->D (1977) • Soit le B-algorithme suivant :

a 4: IF t GOTO52: b

IF u GOTO 3IF v GOTO 9cGOTO 2

3: d GOTO 4

5: e GOTO 4

9 w


� Arsac REn-->D (1977) • a) Etiquetter la première instruction.

Faire précéder toute instruction étiquetée, sauf la première, par une instruction GOTO. On obtient ainsi en écrivant les instructions en ligne, séparées par des ";" : 1 : a; GOTO 4;4 : IF (t) GOTO 5; GOTO 2;2 : b; IF(u) GOTO 3; IF(v) GOTO 9; c; GOTO 2;3 : d; GOTO 4;5 : e; GOTO 4;9 : w Comme vous pouvez le constater, les instructions étiquetées 3 et 5 ne sont pas suivies de Goto à l’étiquette suivante, car l'ajout de ces derniers rend les Goto 4 non terminaux.


� Arsac REn-->D (1977) • b) Introduire les "sinon" :

1: a; GOTO 4 4: Si non t : GOTO 2 Sinon GOTO 5 Finsi2: b; Si non u :

Si non v : c; GOTO 2 Sinon GOTO 9 Fsi Sinon GOTO 3 Finsi

3: d; GOTO 45: e; GOTO 49: w

Il n'est pas nécessaire d'ordonner les lignes; Chacune d'entre elles désigne explicitement son successeur. Par contre une ligne doit être distinguée : celle par laquelle l'exécution doit commencer.


� Arsac REn-->D (1977) • Nous allons faire une nouvelle transformation, chaque ligne est considérée

comme une action du programme, et nommée. De manière simple la ligne p sera appelée Xp.

• L'appel d'une action par GOTO p sera abrégé en Xp, soit <--¨-- un signe qui fera distinguer le nom de la première action Xp, donc on obtient :c) Mise en équation :X1 = a; X4X4 = Si non t : X2 Sinon X5 FsiX2 = b; Si non u :

Si non v : c; X2 Sinon X9 Fsi Sinon X3 Fsi

X3 = d; X4X5 = e; X4X9 = W



• Le remplacement dans une action de GOTO p par la ligne numérotée p se traduit ici par le remplacement d'une variable Xp par sa définition.

• Les actions sont des équations de programme définissant les variables d'actions.

• Chaque variable est définie exactement une fois.

• Les définitions ne sont pas ordonnées, mais l'une d'elles est distinguée (la variable résultat).



• d) Résoudre le système :

Le système comporte une variable W non définie par une équation, son effet est d'occuper une place terminale, mais elle est sans action. Résoudre le système revient à trouver une équation X1<--¨--y(W), si l'on aboutit à cette équation, il suffit de remplacer W par !0 ainsi la formule équivalente, au programme cherché, sera : X1<--y(!0).



• d1)Substitution ( élimination d'une variable) :

On ne peut éliminer ainsi la variable X1, qui est celle qu'on cherche à "calculer". La variable W ne doit pas être substituée non plus jusqu'à ce qu'il n'en reste aucune variable à éliminer. Le processus peut être répété tant que le système comporte des variables autre que X1 ou W, non récursives.



• Substituer les variables non récursives.En appliquant ceci à l'exemple on aura après remplacement de X5, X9, et X3 :X1 = a; X4X4 = Si non t:X2 Sinon e;X4 FsiX2 = b; Si non u :

Si non v : c; X2 Sinon W Fsi

Sinon d; X4 Fsi

Aucune élimination ne peut être faite dans ce nouveau système.



• Dérécursifier X2:Soit une équation récursive : Xi<-¨-fi(X1.......Xi ..Xn , W )dépendant de Xi (récursivité), et peut être des autres variables X et de W.Une équation récursive peut être remplacée par l'équation équivalente suivante : Xi = {fi ((X1)+1,.........!0, ........(Xn )+1, W+1 )}Cette transformation rend non récursive une équation, après quoi le processus de substitution peut reprendre.



• X2 = Répeter b; Si non u :

Si non v: c;!0 Sinon W+1 Fsi Sinon d;(X4) +1 FsiFinrépéter


� Arsac REn-->D (1977) • X4 devient :

X4 =Si non t : Répéter

b; Si non u : Si non v: c;!0

Sinon W+1 FsiSinon d;(X4) +1 Fsi

FinrépéterSinon e; X4 fsi



• Récursifier X4 :

X4 =Répéter Si non t : Répeter

b; Si non u : Si non v: c;!0

Sinon W+2 Fsi Sinon d; !1 Fsi Finrépéter Sinon e; !0 fsiFinrépéter


� Arsac REn-->D (1977) • Enfin X1 devient :

a;Répéter Si non t :

Répeter b;

Si non u : Si non v: c;!0

Sinon W+2 Fsi Sinon d; !1 Fsi Finrépéter Sinon e; !0 fsiFinrépéter



• Remplaçons w par !0 :a;Répéter Si non t :

Répeter b;

Si non u :Si non v: c;Exit(0) Sinon Exit(2) Fsi

Sinon d; Exit(1)FsiFinrépéter

Sinon e; Exit(0) fsiFinrépéter


� Ramshaw(1988)

• Préservation de la structure du programme.

• C'est à dire éliminer tous les "GOTO" et les étiquettes vers lesquelles ils se branchent en insérant des instructions de sortie et des boucles "Repeat-Endloop" tout en gardant le reste du programme inchangé.

• Donc plus de lisibilité.


� Ramshaw(1988)

• Soit l'exemple suivant :

action1; action2; if test3 then Goto G endif;_

action4; action5; G:action6;


� Ramshaw(1988)

• Il se transforme comme suit : action1;action2; Repeat

if test3 then Exit L endif;action4;action5;Exit L ;

Endloop : L action6;


� Williams and Chen(1985)

• Par identification de schémas

• Cette méthode a été proposée par Williams et Chen dans un article intitulé "Restructuring Pascal programs containing Goto statements"

• son principe est basé sur la constitution d'une bibliothèque de schémas équivalents.

• Un schéma pour une forme de branchement.


� Williams and Chen(1985)

• On procède par identification dans le programme proposé d'un schéma type puis remplacement de celui-ci par le schéma équivalent sans branchement.

• La méthode repose sur une triade ( T1, T2, T3 ) d'ensembles de transformations de base, et procède en utilisant la structure hiérarchique de Pascal


� R vers B transformation

• Procédé sémantique : technique basée sur la sémantique de la récursion.

• 1. Définir la zone de donnée = paramètres appelée par valeur, adresse de retour.

• 2. Définir les points d'appels et de retour. On suppose qu'il existe un premier appel dans le programme principal.


� R vers B transformation

3. Chaque Appel se traduit par :- Empiler la zone de donnée- préparer la nouvelle- se brancher au début de la procédure

4. Chaque retour se traduit par :- récupérer l'adresse de retour, Ret.- dépiler la zone de donnée- se brancher à Ret.

programmation procédurale transformations c. transformation définition quelques transformations...

Documents

d goto

c goto

b state

par une instruction

e goto

c d state

b ifu goto

ifv goto