**** éléments de correction td7-LT-RICM2 ****
**** syntaxe abstraite et sémantique****
****Laurent Mounier et Laure Gonnord ****


Exercice 1 
----------

1. Je ne fais que le x:=5+x*2+y :

			Z
		    A      ;
                 i  :=  E
                 |     
                 x     

et pour E le sous-arbre : 
                         E
                     E   +    T
                  E +  T      F
		  T  T * F    i
                  F  F   c    |
		  c  i   |    y
		  |  |   2
		  5  x

2.

x = 5 + x * 2 + y

LD R0, x
MULT R1, R0, 2
ADD R2, 5, R1
LD R4, y
ADD R4, R2, R3
ST R4, x

x = (5 + x) * 2 + y

LD R0, x
ADD R1, 5, R0
MULT R2, R1, 2
LD R4, y
ADD R4, R2, R3
ST R4, x


3.

 Je ne fais que le x:=5+x*2+y :

			      Z
		    A : Sto         ;
	        i  :=  E
             Load(x,R1)

et pour E le sous-arbre : 
                         E
                     E   +    T
                  E +  T      F
		  T  T * F    i
                  F  F   c    |
		  c  i   |    y
		  |  |   2
		  5  x


4. 
	Z -> i = E
	E -> E + E | E * E | i | c


Exercice 2
----------

1 et 2.

En ADA : 

	syntaxe concrete :
		F -> "for" IDF "in" INTERVALLE "loop" SEQ_INST "end" "loop"
		INTERVALLE -> EXP ".." EXP
		SEQ_INST -> ...
		IDF ...

	syntaxe abstraite 
		F -> for (idf_iteration, exp_debut, exp_fin, corps)

En C :

	syntaxe concrete :
		F -> "for" "(" INST ";" EXP ";" INST ")" BLOC
		BLOC -> epsilon | INST | "{" SEQ_INST "}"
		SEQ_INST -> INST ; SEQ_INST | INST
		EXP -> ...

	syntaxe abstraite :
		F -> for (inst_init, exp_arret, inst_progression, corps)

3. Verifier qu'une instruction "for" est bien typée :

  a) en Ada :
	- verifier que "exp_debut" et "exp_fin" sont du même type T, 			 et que l'intervale "exp_debut".."exp_fin" est un type discret.
	- verifier que le "corps" est correctement typé, avec l'hypothèse 
	  que l'"idf_iteration" est de type T.

  b) en C :
	- verifier que "inst_init", "exp_arret", "inst_progression" et "corps" 
	   sont bien typés.
	- vérifier que "exp_arret" est de type "int".

Remarques :
	- en C la variable d'iteration n'est pas explicite
		 (elle peut même ne pas exister ...)
	- dans le cas general il est bien sur impossible de verifier 
	  a la compilation que l'iteration va se terminer ...


Exercice 3
----------

pgm1 : depend de l'ordre d'évaluation des "+"
	ex: "+" associatif à gauche -> z=14

pgm2 : on trouve z=6

pgm3 : f fait un "effet de bord", le resultat dépend de l'ordre
d'evaluation du "+"
	on trouve soit z=5 (evaluation Gauche-Droite),
		  soit z=6 (evaluation Droite-Gauche)

pgm4 : idem, on trouve soit z=5 ((evaluation Gauche-Droite), 
	soit z=6 (evaluation  Droite-Gauche)


Exercice 4 :
-----------

1. Rep : 4, pas de soucis

2. Rep : 7, pas de soucis

3. Rep : ca depend de la portée de l'opérateur "soit"
	on peut lier le "x" de "y=x+1" soit au 1er x, soit au 2nd ...

4. idem

5. Rep : 9

6. Rep : 12, pas de soucis

7.  Rep : cela dépend de la valeur de x que l'on prend pour calculer f(5) !
           liaison dynamique : on prend x=7
           liaison statique : on prend x=3 ...

****