Interpréteur du brainfuck

Vous connaissez le brainfuck? C'est un langage de programmation qui se limite aux caractères suivants: - + [ ] < > , et .
Regardez par exemple un exemple de code en brainfuck:

Code:: ,>++++++[<-------->-],,[<+>-],<.>

Indigeste n'est-ce pas? Ce programme additionne 2 nombres à 1 seul chiffre puis ensuite affiche le résultat si ce nombre est composé que d'un seul chiffre (d'après Wikipédia).
Le but de cet exercice est de créer l'interprète de ce langage. N'ayez pas peur: à mes yeux, il est beaucoup plus facile de créer l'interprète du langage que de l'utiliser.

Pour toutes informations sur les instructions, je vous laisser aller voir la page wikipedia:
http://fr.wikipedia.org/wiki/Brainfuck
Il y contient toutes les informations sur les différents instructions: vous verrez, c'est assez facile.

Invité

Alors ça c'est vraiment le genre d'exos que j'aime pas. Mais bon j'ai essayé quand même, il est pas fonctionnel, même si il compile.

test.c

Code:: #include <stdio.h>
#include <stdlib.h>
#include "test.h"

static char *ptr;

void traiter(char code)
{
switch (code)
{
case '+':
(*ptr)++;
break;
case '-':
(*ptr)--;
break;
case '.':
putchar(*ptr);
break;
case '>':
ptr++;
break;
case '<':
ptr--;
break;
case ',':
*ptr = getchar();
break;
case '[':
while(ptr != NULL)
{
while(*ptr != ']')
{
ptr++;
traiter(*ptr);
}
}
default:
exit(-1);
}
}

void executer(char chaine[])
{
int i=0;
while(chaine[i] != '\0')
{
traiter(chaine[i]);
i++;
}
}

int main(void)
{
char test[] = "--->,+++.";
executer(test);
printf("%s", ptr);
return 0;
}

test.h

Code:: #ifndef TEST_H_INCLUDED
#define TEST_H_INCLUDED

void traiter(char code);
void executer(char chaine[]);

#endif

Je sais même pas si je suis sur la bonne piste, bref j'ai du mal à me motiver sur celui-ci Smile

Edit : Je viens de me rendre compte que j'ai oublié les break
Edit2 : Plus de concentration et de compréhension, ça merde quand même. Avec gdb je sais juste que ça bug dans la fonction traiter(), mais où je vois pas ça compile.

Il ne faut pas faire comme c'est écris sur wikipédia: si j'ai donné le lien, c'est pour vous donner la signification de chaque caractères du brainfuck. C'est tout à fait normal que ton programme plante enfaite ^^ ! Tu déclares un pointeur sans dire sur quelle adresse elle doit pointer: ducoup elle pointe sur l'adresse déja présente en mémoire: une adresse qui n'est pas alloué pour ton programme. Quand tu fais ptr++ ou ptr--, ça ne plante pas et c'est normal: tu ne fais que changer l'adresse sur lequel pointe ton pointeur. Parcontre, normalement, ton programme plante quand tu essai d'accéder à la valeur derrière cette adresse, de cette façon: *ptr. Le système d'exploitation n'est pas content car tu essais d'accéder à une valeur dont l'adresse de variable ne t'es pas alloué. Tu veux une technique pour avoir une plage de variable "infini" (entre parenthèses parce que rien n'est vraiment infini en informatique) ? Ou je te laisse réfléchir?

Invité

Ok j'ai pigé, d'ailleurs ça bug plus, je vais réfléchir un peu demain et si je ne m'en sors pas, je te demanderais de m'aider Wink

Merci

Invité

Bon il a fallu que je comprenne bien le principe du brainfuck, mais c'est bon maintenant

Code:: #include <stdio.h>
#include <stdlib.h>

int p, r, q;
char a[5000], f[5000], b, o, *s=f;

void interpreter(char *c)
{
char *d;

r++;
while( *c )
{
   switch(o=1,*c++)
   {
   case '<': p--; break;
   case '>': p++; break;
   case '+': a[p]++; break;
   case '-': a[p]--; break;
   case '.': putchar(a[p]); fflush(stdout); break;
   case ',': a[p]=getchar();fflush(stdout); break;
   case '[':
      for( b=1,d=c; b && *c; c++ )
         b+=*c=='[', b-=*c==']';
      if(!b)
{
         c[-1]=0;
         while( a[p] )
            interpreter(d);
         c[-1]=']';
         break;
}
   case ']':
      puts("UNBALANCED BRACKETS"), exit(0);
   case '#':
      if(q>2)
{
printf("%2d %2d %2d %2d %2d %2d %2d %2d %2d %2d\n%*s\n",
*a,a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9],3*p+2,"^");
}
      break;
   default: o=0;
   }
   if( p<0 || p>100)
      puts("RANGE ERROR"), exit(0);
}
r--;
}

int main(void)
{

char test[] = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.";
interpreter(test);
return EXIT_SUCCESS;
}

Edit : Je me suis beaucoup aidé d'autres code pour comprendre le principe du brainfuck.

Bien joué

! Je me pencherai un peu plus sur ton code plus tard. Sinon, bien joué si ton interprète fonctionne correctement Smile

! Juste, permet moi de te faire une petite remarque ^^ ! Pour la gestion des adresses en mémoire de ton programme: tu initialises un énorme tableau de taille fixe ce qui fait que t'as une plage de variable limité à 5000 et une grosse consommation de mémoire. Pour remédié à ce problème: moi j'avais utilisé une liste doublement chainé (même principe que deque mais en différent: http://upload.wikimedia.org/wikipedia/commons/thumb/2/26/Liste_doublement_cha%C3%AEn%C3%A9e.png/350px-Liste_doublement_cha%C3%AEn%C3%A9e.png )

Voilà Smile

! En tous cas, bien joué Razz