Skip to content

Latest commit

 

History

History
134 lines (131 loc) · 5.87 KB

brainfuck.md

File metadata and controls

134 lines (131 loc) · 5.87 KB

BrainFuck

Le programme exécuté est un tuple, Cp, composé de 3 "variables" :

  1. M, 30 000 cases mémoires indexées de 0 à 29 999 (chacune pouvant stocker un entier de 0 à 255).
  2. p, pointeur sur la case mémoire actuelle.
  3. i, instruction (1 caractère) suivante du programme exécuté.

Il existe 8 opérations :

  • L'incrémentation : Let Cp = (M, p, i); Increment(Cp) = (M', p, i+1); d'p=dp + 1
     La case courante, p, va incrémenter sa valeur, dp, (initialisée à 0) de 1. Suite à cette opération on passe à l'instruction suivante sans changer de case mémoire.
    [→0,0,0,0,0,0]0+
    Instruction : +
    [→1,0,0,0,0,0]0...
  • La décrémentation : Let Cp = (M, p, i); Decrement(Cp) = (M', p, i+1); d'p=dp - 1
     La case courante va décrémenter sa valeur de 1. Suite à cette opération on passe à l'instruction suivante sans changer de case mémoire.
    [→3,0,0,0,0,0]0-
    Instruction : -
    [→2,0,0,0,0,0]0...
  • "Left" : Let Cp = (M, p, i); Left(Cp) = (M, p', i+1); p'=p - 1
     Change le case mémoire pointée par p. "Décalle" le pointeur d'une case de M vers la gauche (-1).
    [0,→0,0,0,0,0]1<
    Instruction : <
    [→0,0,0,0,0,0]0...
  • "Right" : Let Cp = (M, p, i); Right(Cp) = (M, p', i+1); p'=p + 1
     Change le case mémoire pointée par p. "Décalle" le pointeur d'une case de M vers la droite (+1).
    [0,→0,0,0,0,0]1>
    Instruction : >
    [0,0,→0,0,0,0]2...
  • "Out" : Let Cp = (M, p, i); Out(Cp) = (M, p, i+1) = ^ out ← dp
     Affiche la valeur du code ASCII contenue dans la case mémoire courante, p.
    [0,→97,0,0,0,0]1.
    Instruction : .
    La machine affiche "a".
    [0,→97,0,0,0,0]1...
  • "In" : Let Cp = (M, p, i) ^ Read(in) = v; In(Cp) = (M', p, i); d'p=v
     Lit une valeur entrée et la stocke dans la case mémoire courante, p.
    [0,→97,0,0,0,0]1,
    Instruction : ,
    Entre "22".
    [0,→22,0,0,0,0]1...
  • "Jump to" : Let Cp = (M, p, i);
    Jumpto(Cp) = dp = 0 ⇒ (M, p, i' + 1) ^ bound(i, i')
    dp ≠ 0 ⇒ (M, p, i' + 1)

     Controle si la case mémoire courante, p, vaut 0. Dans le cas où p vaut 0 avance jusqu'à l'instruction "]" (back to), sinon continue normalement.
  • "Back to" : Let Cp = (M, p, i);
    Backto(Cp) = dp = 0 ⇒ (M, p, i' + 1)
    dp ≠ 0 ⇒ (M, p, i' + 1) ^ bound(i', i)

     Controle si la case mémoire courante, p, vaut 0. Dans le cas où p vaut 0 continue normalement, sinon recule jusqu'à l'instruction "[" (jump to), .

Exemple de programme en BrainFuck :

++++++++++Donne la valeur 10 à la case mémoire qui va stocker le nombre d'itérations
[Boucle initiale qui affecte des valeurs utiles au tableau
>+++++++>++++++++++>+++>+<<<<-Ajoute 7 à la case suivante p+1, 10 à la case p+2, 3 à p+3, 1 à p+4, puis décrémente le nombre d'itérations de 1 (jusqu'à ce que dp = 0)
]
A la sortie de la boucle le tableau contient :
>++.'H' = 72 (70 + 2)
>+.'e' = 101 (100 + 1)
+++++++.'l' = 108 (101 + 7)
.'l' = 108
+++.'o' = 111 (108 + 3)
>++.espace = 32 (30 + 2)
<<+++++++++++++++.'W' = 87 (72 + 15)
>.'o' = 111
+++.'r' = 114 (111 + 3)
------.'l' = 108 (114 - 6)
--------.'d' = 100 (108 - 8)
>+.'!' = 33 (32 + 1)
>.nouvelle ligne = 10