# TD6 --- L3 -- Langage et Compilation

# TD6 --- L3 Langage et Compilation --

# Le retour de la MVàP

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.

## Préliminaire

Sortez un papier, un crayon et une gomme. Imaginez pour l'instant que le pc devant vous sert seulement à visionner cette feuille d'exercice.

## Code MVàP 1

Soit le programme suivant en MVàP :

      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

Une fois assemblé, ce code devient :

     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

Commenter et compléter le début de trace suivant. Commenter le code original. Que réalise-t-il?
Le début de l'exécution donnant la trace suivante :

      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
         |               |
         |               |
         |               |
         |               |

## Code MVàP 2

Soit le programme suivant en MVàP :

      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

Une fois assemblé, ce code devient :

     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

Compléter les traces d'exécution suivantes. Identifier les appels de fonctions. Repérer les blocs d'activation. Que réalise le code?
Trace partielle :

      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

## autocorrection

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 sources de la MVaP et suivez les instructions avec les tests.
Utilisez la MVàP pour vérifier que celle ci ne se trompe pas et donne la même réponse que votre crayon.

## Production de code

Pour chaque programme décrit informellement ci-dessous, écrire un programme MVàP et testez le. Le fichier texte `.mvap` 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).
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.
Fonction valeur absolue et son appel pour un entier entré par l'utilisateur.
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.
Fonction de Fibonnacci et appel d'ycelle dans le main pour 2 valeurs lues auprès de l'utilisateur.
Et parce qu'il faut bien une question un peu plus difficile.
Reprendre la fonction chapeau. Codez là en récursion terminale.