<!DOCTYPE html>

<html lang="fr-FR">
<head>
    <meta  charset="utf-8" />
<title>TD6 --- L3 -- Langage et Compilation</title>
      <link rel="stylesheet" href="../styletp.css" type="text/css" media="screen, print">

  </head>

  
  <body>
    <h1>TD6 --- L3   Langage et Compilation --</h1>
    <h1>Le retour de la MVàP</h1>

    Fort de notre expériennce de la semaine passée, nous continuons à programmer en MVàP. Pour ceux qui regrettent le python et ces fonctions : pas de problème
    la MVàP permet d'en écrire, et à la fin de ce TD en salle machine, les fonctions n'auront plus de secrets pour vous. 

    <h2>Préliminaire</h2>
    Sortez un papier, un crayon et une gomme. Imaginez pour l'instant que le pc devant vous sert seulement à visionner cette feuille d'exercice.


    <a id="code"></a>
    <h2>Code MVàP 1</h2>
Soit le programme suivant en MVàP :
    <pre>
  JUMP 0
LABEL 1   
  PUSHL -3
  PUSHI 2
  MUL
  STOREL -4
  RETURN
RETURN
LABEL 0   
  PUSHI 0
  PUSHI 2
  CALL  1
  POP
  WRITE
  POP
  HALT
</pre>

Une fois assemblé, ce code devient :
<pre>
 Adr |  Instruction
-----+---------------
   0 | JUMP       11 
   2 | PUSHL      -3 
   4 | PUSHI       2 
   6 | MUL           
   7 | STOREL     -4 
   9 | RETURN        
  10 | RETURN        
  11 | PUSHI       0 
  13 | PUSHI       2 
  15 | CALL        2 
  17 | POP           
  18 | WRITE         
  19 | POP           
  20 | HALT          
</pre>
    
<div class="question"> Commenter et compléter le début de trace suivant.
Commenter le code original. Que réalise-t-il?</div>


Le début de l'exécution donnant la trace suivante :

<pre>
  pc |               |    fp   pile
====================================================
   0 | JUMP       11 |     0 [ ] 0
  11 | PUSHI       0 |     0 [ ] 0
  13 | PUSHI       2 |     0 [ 0 ] 1
  15 | CALL        2 |     0 [ 0 2 ] 2
   2 | PUSHL      -3 |     4 [ 0 2 17 0 ] 4
     |               |
     |               |
     |               |
     |               |
</pre>
      
    <a id="code"></a>
    <h2>Code MVàP 2</h2>
Soit le programme suivant en MVàP :
    <pre>
  JUMP 0
LABEL 1
  PUSHL -3
  PUSHI 2
  MUL
  STOREL -4
  RETURN
RETURN
LABEL 2
LABEL 3
  PUSHL -4
  PUSHL -3
  PUSHI 1
  ADD
  INF
  JUMPF 4
  PUSHI 0
  PUSHL -3
  CALL 1
  POP
  STOREL -4
  JUMP 3
LABEL 4
  PUSHL -4
  STOREL -5
  RETURN
RETURN
LABEL 0
  PUSHI 0
  PUSHI 3
  PUSHI 5
  CALL 2
  POP
  POP
  WRITE
  POP
  HALT
</pre>

Une fois assemblé, ce code devient :
<pre>
 Adr |  Instruction
-----+---------------
   0 | JUMP       38 
   2 | PUSHL      -3 
   4 | PUSHI       2 
   6 | MUL           
   7 | STOREL     -4 
   9 | RETURN        
  10 | RETURN        
  11 | PUSHL      -4 
  13 | PUSHL      -3 
  15 | PUSHI       1 
  17 | ADD           
  18 | INF           
  19 | JUMPF      32 
  21 | PUSHI       0 
  23 | PUSHL      -3 
  25 | CALL        2 
  27 | POP           
  28 | STOREL     -4 
  30 | JUMP       11 
  32 | PUSHL      -4 
  34 | STOREL     -5 
  36 | RETURN        
  37 | RETURN        
  38 | PUSHI       0 
  40 | PUSHI       3 
  42 | PUSHI       5 
  44 | CALL       11 
  46 | POP           
  47 | POP           
  48 | WRITE         
  49 | POP           
  50 | HALT 
</pre>
    
<div class="question"> Compléter les traces d'exécution suivantes. Identifier les appels de fonctions. Repérer les blocs d'activation. Que réalise le code?</div>


Trace partielle :
<pre>
  pc |               |    fp   pile
====================================================
   0 | JUMP       38 |     0 [ ] 0                  
  38 | PUSHI       0 |     0 [ ] 0		    
  40 | PUSHI       3 |     0 [ 0 ] 1		    
  42 | PUSHI       5 |     0 [ 0 3 ] 2		                 
  44 | CALL       11 |     0 [ 0 3 5 ] 3                         
  11 | PUSHL      -4 |      
     |               |
     |               |
     |               |
  18 | INF           |     5 [ 0 3 5 46 0 3 6 ] 7	        
  19 | JUMPF      32 |     5 [ 0 3 5 46 0 1 ] 6		
  21 | PUSHI       0 |     5 [ 0 3 5 46 0 ] 5		
  23 | PUSHL      -3 |     5 [ 0 3 5 46 0 0 ] 6		
  25 | CALL        2 |     5 [ 0 3 5 46 0 0 5 ] 7                    
   2 | PUSHL      -3 |     9 [ 0 3 5 46 0 0 5 27 5 ] 9      
   4 | PUSHI       2 |     9 [ 0 3 5 46 0 0 5 27 5 5 ] 10   
   6 | MUL           |     9 [ 0 3 5 46 0 0 5 27 5 5 2 ] 11 
   7 | STOREL     -4 |     9 [ 0 3 5 46 0 0 5 27 5 10 ] 10  
   9 | RETURN        | 
     |               |
     |               |
     |               |
  11 | PUSHL      -4 |     5 [ 0 10 5 46 0 ] 5		
  13 | PUSHL      -3 |     5 [ 0 10 5 46 0 10 ] 6	
  15 | PUSHI       1 |     5 [ 0 10 5 46 0 10 5 ] 7	
  17 | ADD           |     5 [ 0 10 5 46 0 10 5 1 ] 8	      
  18 | INF           |     5 [ 0 10 5 46 0 10 6 ] 7	
  19 | JUMPF      32 |     5 [ 0 10 5 46 0 0 ] 6	             
  32 | PUSHL      -4 |     5 [ 0 10 5 46 0 ] 5		
  34 | STOREL     -5 |     5 [ 0 10 5 46 0 10 ] 6	
  36 | RETURN        |     5 [ 10 10 5 46 0 ] 5         
  46 | POP           |     0 [ 10 10 5 ] 3          
  47 | POP           |     0 [ 10 10 ] 2	    
  48 | WRITE         |     0 [ 10 ] 1		    
10						                  
  49 | POP           |     0 [ 10 ] 1		   
  50 | HALT          |     0 [ ] 0                 
</pre>




<h2>autocorrection</h2>
Vous pouvez éteindre votre papier, votre gomme et votre crayon et reprendre une activité normale.
Si ce n'est pas déjà fait la semaine dernière, téléchargez les <a href="MVaP.tar.gz">sources de la MVaP</a> et suivez les instructions avec les tests. 

<div class="etape">
Utilisez la MVàP pour vérifier que celle ci ne se trompe pas et donne la même réponse que votre crayon.  
</div>




<a id="production"></a>
<h2>Production de code</h2>

Pour chaque programme décrit informellement ci-dessous, écrire un programme MVàP et testez le. Le fichier texte <code>.mvap</code> doit contenir une instruction par ligne et un saut de ligne après chaque instruction. Vous pouvez commenter votre code en préfixant chaque ligne par un dièse (hash). Attention à bien prendre soin de sauter une ligne y compris après la dernière instruction (HALT).

<div class="question">
Fonction f(x)=1-x. Fonction g(x)=1+x.
Main : appel de f(a)*g(a) pour un entier a lu auprès de l'utilisateur. 
</div>

<div class="question">
Fonction valeur absolue et son appel pour un entier entré par l'utilisateur.
</div>

<div class="question">
Fonction 2^n (2 chapeau n c'est bien ça) et son appel pour un entier entré par l'utilisateur. 
Évidemment on fera une fonction récursive sinon ce n'est pas drôle.
</div>

<div class="question">
Fonction de Fibonnacci et appel d'ycelle dans le main pour 2 valeurs lues auprès de l'utilisateur.
</div>

Et parce qu'il faut bien une question un peu plus difficile.
<div class="question">
Reprendre la fonction chapeau. Codez là en récursion terminale.
</div>

</body></html>