On veut le code, on veut tripoter

Éviter les répétitions

<?php
/**
 * @brief fonction qui interprete un code brainfuck
 * solution sans preprocessing
 * @param $code le code a interpreter
 */
function brainfuck_verbeux($code){
  $code_len = strlen($code);
  $mem = array();
  $indice_memoire = 0;
  for ($i=0;$i<$code_len;$i++){
    if (!isset($mem[$indice_memoire])) $mem[$indice_memoire]=0;
    else {
       // les valeurs sont comprises entre 0 et 256.
      $mem[$indice_memoire] = (256 + $mem[$indice_memoire] ) % 256;
    }
    switch($code[$i]){
      case '>': $indice_memoire++; break;
      case '<': $indice_memoire--; break;
      case '.': echo chr($mem[$indice_memoire]); break; // on affiche la valeur
      case ',': $mem[$indice_memoire]=prompt(); break;
      case '+': $mem[$indice_memoire]++; break; // on incremente la valeur
      case '-': $mem[$indice_memoire]--; break; // on decremente la valeur
      case ']':
        $n = 1; // on doit remonter $n [ en arriere
        while ($n){
          $i --; // on cherche en arriere
          if ($code[$i]==']') $n++; // si on rencontre un ], alors on attend un [ de plus
          else if ($code[$i]=='[') $n--; // si on trouve un [. alors on en attend un de moins
        } $i--; // on "jump" devant le [ correspondant.
        break;
      case '[':
        if ( $mem[$indice_memoire] == 0 ){
          $n = 1; // on doit monter $n ] en avant
          while ($n){
            $i ++;
            if ($code[$i]=='[') $n++; // si on rencontre un [, alors on attend un ] de plus
            else if ($code[$i]==']') $n--; // si on trouve un ]. alors on en attend un de moins
          } // ici, on a pas de $i-- parce-qu'on jump apres le ]
      } break;
    }
  }
}


brainfuck_verbeux(
'++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.');
brainfuck_verbeux(',>,<+>+<.>.');

?>

#!/usr/bin/env python
#-*- encoding: utf-8 -*-
"""
bf.py
Brainfuck intepretor
"""

import sys

def brainfuck(code, inchan):
    """
    Read the brainfuck code from "code", input data from inchan, and yields
    output.
    """
    jumpstable = [] # List of tuples (from, dest)

    # Loop on the whole code in order to fill the jump table
    for startpos, instruction in enumerate(code):
        if instruction == '[':
            n = 1
            for offset, endinstruction in enumerate(code[startpos:]):
                if endinstruction == '[':
                    n += 1
                elif endinstruction == ']':
                    n -= 1
                    if n == 1:
                        jumpstable.append((startpos, startpos + offset))
                        break
    memory = 30000 * [0] # The memory is 30000 cases wide.
    memindex = 0 # Start at position 0

    codepos = 0 # Position in the code
    while codepos < len(code): # Main loop
        inst = code[codepos]
        if inst == '<': memindex -= 1
        elif inst == '>': memindex += 1
        elif inst == '+': memory[memindex] += 1
        elif inst == '-': memory[memindex] -= 1
        elif inst == '.': yield memory[memindex]
        elif inst == ',': memory[memindex] = inchan.next()
        elif inst == '[' and memory[memindex] == 0:
            endpos = filter(lambda (s, e): s == codepos, jumpstable)[0][1]
            codepos = endpos
        elif inst == ']':
            stpos = filter(lambda (s, e): e == codepos, jumpstable)[0][0]
            codepos = stpos - 1
        codepos += 1
        memory[memindex] = (255 if memory[memindex] < 0
                                else memory[memindex] % 256)

def stdinchan():
    """
    Read the input data from stdin. If EOF encountered, always return 0.
    """
    while True:
        try:
            yield ord(sys.stdin.read(1))
        except EOFError:
            break
    while True:
        yield 0

code = '''>++++++++++>+>+[
    [+++++[>++++++++<-]>.<++++++[>--------<-]+<<<]>.>>[
        [-]<[>+<-]>>[<<+>+>-]<[>+<-[>+<-[>+<-[>+<-[>+<-[>+<-
            [>+<-[>+<-[>+<-[>[-]>+>+<<<-[>+<-]]]]]]]]]]]+>>>
    ]<<<
]'''

for char in brainfuck(code, stdinchan()):
    sys.stdout.write(chr(char))
    sys.stdout.flush()

"""
Copyright (c) 2008 Pierre "wgmpgp" Bourdon <root@wgmpgp.is-a-geek.org>

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
"""

#include "brainfuck.h"

int main(void)
{

	brainfuck("++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.");
	brainfuck(",>,<+>+<.>.");

	return (0);
}

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define FAILLURE 0
#define SUCCESS 1

/*Structure de donnée contenant la memoire de l' intérpreteur*/
typedef struct Bf_mem{
	char * memory;
	int memorySize;
	int currentMemPosition;
}Bf_mem;

/*Calcul l'espace memoire nécéssaire au programme*/
int necessaryMemorySize(char * code);
/*Initialise la structure de donnée*/
int init(char * code, Bf_mem * mem);
/*Fonction principal du module*/
int brainfuck(char * code);
/*L' interpréteur en lui meme*/
int bf_interpreteur(char * code, Bf_mem * memory);
/*Liberation de la memoire*/
void freeMem(Bf_mem * mem);

#include "brainfuck.h"

/*Fonction Principal:
Initialisation et appel de l' interpréteur
*/
int brainfuck(char * code)
{
	int r = FAILLURE;
	Bf_mem memory;

	if(init(code, &memory) == SUCCESS)
	{
		r = bf_interpreteur(code, &memory);
                                freeMem(&memory);
	}

	return (r);
}

/*L' interpréteur en lui même
TODO: Gestion d' un code mal écrie*/
int bf_interpreteur(char * code, Bf_mem * memory)
{
	unsigned int i = 0;
	int r = SUCCESS;

	for(i = 0; i < strlen(code); i++)
	{
		switch (code[i])
		{
		case '>':
			/*TODO Gestion des indices hors memoire*/
			memory->currentMemPosition++;
			break;
		case '<':
			/*TODO Gestion des indices or memoire*/
			memory->currentMemPosition--;
			break;
		case '+':
			memory->memory[memory->currentMemPosition]++;
			break;
		case '-':
			memory->memory[memory->currentMemPosition]--;
			break;
		case '.':
			putchar(memory->memory[memory->currentMemPosition]);
			break;
		case ',':
			memory->memory[memory->currentMemPosition] = getchar();
			break;
		case '[':
			/*Si la case memoire pointé est a zero on saute a son crochet fermant*/
			if(memory->memory[memory->currentMemPosition] == 0)
			{
				int numOfBrackets = 1;
				while(numOfBrackets != 0)
				{
					i++;
					if(code[i] == '[')
						numOfBrackets++;

					else if( code[i] == ']')
						numOfBrackets--;
				}
			}
			break;
		case ']':
			/*On doit remonté a son crochet ouvrant*/
			if(1)
			{
				int numOfBrackets = 1;
				while(numOfBrackets != 0)
				{
					i--;
					if(code[i] == '[')
						numOfBrackets--;

					else if( code[i] == ']')
						numOfBrackets++;
				}
				/*On passe un caractere en arriere pour retourné sur l' evaluation du caractere '['*/
				i--;
			}
			break;
		default:
			break;
		}
	}

	return (r);
}

/*initialisation de la structure memoire*/
int init(char * code, Bf_mem * mem)
{
	int r = FAILLURE;
	mem->currentMemPosition = 0;
	mem->memorySize = necessaryMemorySize(code);

	mem->memory = 0;
	mem->memory = calloc(1,mem->memorySize);

	if(mem->memory != 0)
		r = SUCCESS;

	return (r);
}

/*Retourne l'espace memoire maximal nécéssaire au programme*/

int necessaryMemorySize(char * code)
{
	unsigned int i = 0;
	int maxSize = 1;
	int tmpSize = 1;

	for( i = 0; i < strlen(code); i++)
	{
		switch(code[i])
		{
		case '>':
			tmpSize++;
			if(tmpSize > maxSize)
				maxSize++;
			break;
		case '<':
			tmpSize--;
			break;
		default: 
			break;
		}
	}

	return (maxSize);
}
void freeMem(Bf_mem * mem)
{
	mem->currentMemPosition = 0;
	mem->memorySize = 0;
	free(mem->memory);

	mem->memory = 0;
}

1. ce qu’il y a avant le curseur
2. le curseur
3. ce qu’il y a après le curseur

-module(brainfuck).
-export([start/1]).

start(Str) -> brainfuck([], Str, [], [0]).

brainfuck(_, [], _, _) -> ok;
brainfuck(A, B, [], C) -> brainfuck(A, B, [0], C);
brainfuck(A, B, C, []) -> brainfuck(A, B, C, [0]);
brainfuck(Prevs, [Act|Next], [CPrev|CPrevs], [CAct|CNext]) ->
    case [Act] of
	">" -> brainfuck([Act|Prevs], Next, [CAct, CPrev|CPrevs], CNext);
	"<" -> brainfuck([Act|Prevs], Next, CPrevs, [CPrev, CAct|CNext]);
	"+" -> brainfuck([Act|Prevs], Next, [CPrev|CPrevs], [(CAct + 1)|CNext]);
	"-" -> brainfuck([Act|Prevs], Next, [CPrev|CPrevs], [(CAct - 1)|CNext]);
	"." -> 
	    io:put_chars([CAct]),
	    brainfuck([Act|Prevs], Next, [CPrev|CPrevs], [CAct|CNext]);
	"," ->
	    [NewCAct|_] = io:get_line("> "),
	    brainfuck([Act|Prevs], Next, [CPrev|CPrevs], [NewCAct|CNext]);
	"[" when CAct == 0 ->
	    {A, B, C, D} = skip([Act|Prevs], Next, [CPrev|CPrevs], [CAct|CNext]),
	    brainfuck(A, B, C, D);
	"["  -> brainfuck([Act|Prevs], Next, [CPrev|CPrevs], [CAct|CNext]);
	"]" when CAct == 0 -> brainfuck([Act|Prevs], Next, [CPrev|CPrevs], [CAct|CNext]);
	"]" -> 
	    {A, B, C, D} = back(Prevs, [Act|Next], [CPrev|CPrevs], [CAct|CNext]),
	    brainfuck(A, B, C, D)
    end.

skip(_, _, _, []) -> exit("Boucle non fermée");
skip(Prevs, [Act|Next], [CPrev|CPrevs], [CAct|CNext]) ->
    case [Act] of
	"]" -> {Prevs, [Act|Next], [CPrev|CPrevs], [CAct|CNext]};
	"[" ->
	    {A, B, C, D} = skip([Act|Prevs], Next, [CPrev|CPrevs], [CAct|CNext]),
	    skip(A, B, C, D);
	_ -> skip([Act|Prevs], Next, [CPrev|CPrevs], [CAct|CNext])
    end.

back(_, _, [], _) -> exit("Boucle non fermée");
back([Prev|Prevs], [Act|Next], [CPrev|CPrevs], [CAct|CNext]) ->
    case [Prev] of
	"[" -> {[Prev|Prevs], [Act|Next], [CPrev|CPrevs], [CAct|CNext]};
	"]" ->
	    {A, B, C, D} = back([Prev|Prevs], [Act|Next], [CPrev|CPrevs], [CAct|CNext]),
	    back(A, B, C, D);
	_ -> back(Prevs, [Prev, Act|Next], [CPrev|CPrevs], [CAct|CNext])
    end.

$ erl
...
1> c(brainfuck).
{ok,brainfuck}
2> brainfuck:start("votre code").

#include <iostream>
#include <string>
#include <vector>
#include <stack>

using namespace std;

int main(int argc, char *argv[])
{
    if (argc < 2) {
	cout << "Specifiez un code Brainfuck !" << endl;
        return -1;
    }
	
    string code = argv[1];

    vector<char> memory; //Tableau d'octets
    vector<char>::iterator memPtr = memory.begin(); //Represente le pointeur 
    vector<int> brackets(code.length()); //Correspondance des positions de '[' et ']'
    stack<char,vector<char>> bracketStack; //Pile pour stocker la position des '['

    memory.push_back(0);
    memPtr = memory.begin();
	
    //On parcourt une premiere fois le code pour noter les correspondances entre '[' et ']'
    //(a chaque [ correspond un ] et vice versa)
    for (size_t i = 0; i < code.length(); i++) {
	if (code[i] == '[')
            bracketStack.push(i);
	    if (code[i] == ']') {
		if (bracketStack.empty()) {
		    cerr << "] inattendu en position" << i << endl;
		    return 1;
		}
		else {
		    int pos = bracketStack.top(); //On cherche le '[' correspondant
		    bracketStack.pop();
		    brackets[i] = pos; //Il correspond au ']' trouvé
		    brackets[pos] = i; //et inversement
		}
	    }
	}
    if (!bracketStack.empty()) {
        cerr << "[ non fermé en position" << bracketStack.size() << endl;
        return 1;
    }

    //Deuxieme parcourt du code : execution
    for (size_t i = 0; i < code.length(); i++) {
        switch (code[i]) {
       	    case '<' : if (memPtr != memory.begin()) memPtr--; break;
	    case '>' :
                if (memPtr == memory.end() - 1) {
	            memory.push_back(0);
		    memPtr = memory.end() - 1;
		}
		else 
                    memPtr++; 
		break;
	    case '+' : (*memPtr)++; break;
            case '-' : (*memPtr)--; break;
	    case '.' : cout.put(*memPtr); break;
	    case ',' : *memPtr = cin.get(); break;
	    case '[' : if (!(*memPtr)) i = brackets[i]; break;
	    case ']' : if (*memPtr) i = brackets[i]; break;
	}
    }
    return 0;
}

• La structure de donnée utilisée pour stocker la mémoire
• Le type des données
• Le flux du code

La mémoire

module type Memory = sig
  type 'a t
  val update : ('a -> 'a) -> 'a t -> 'a t
  val get : 'a t -> 'a
  val forward : 'a t -> 'a t
  val backward : 'a t -> 'a t
  val single : 'a -> 'a t
end

module Zipper : Memory = struct
  type 'a t = {
    before : 'a list;
    current : 'a;
    after: 'a list;
    default : 'a;
  }
  let update f ({current = a} as zipper) = {zipper with current = f a}
  let get {current = a} = a
  let forward zipper = match zipper.after with
    | [] -> { zipper with current = zipper.default; 
		before = zipper.current :: zipper.before;  }
    | t :: q -> {zipper with before = zipper.current :: zipper.before; current = t; 
		   after = q}

  let swap zipper =  { zipper with after = zipper.before; before = zipper.after }
  let backward z = swap (forward (swap z))
  let single a = {
    before = []; after = []; current = a; default = a
  }
end

Le type des données

module type Data = sig 
  type t
  val zero : t
  val incr : t -> t
  val decr : t -> t
  val print : t -> unit
  val read : unit -> t
end

module Int : Data = struct
  type t = int
  let incr = (+) 1 and decr x = x - 1 and zero = 0
  let print = Printf.printf "%c" |< char_of_int
  let read () = int_of_char (input_line stdin).[0]
end

Le flux de code

module Stream = struct
  type 'a t = 'a array * int

  let at (array, n) = array.(n)
  let prev (array, n) = (array, n-1)
  let next (array, n) = (array, n + 1)
  let of_chan chan = 
    let buffer = Buffer.create 100 in
    let rec loop () = 
      match (try Some (input_line chan) with _ -> None) with
	| Some l -> Buffer.add_string buffer l; loop ()
	| None -> ()
    in loop ();
      let s = Buffer.contents buffer in
      (Array.init (String.length s) (String.get s), 0)

end

module Brainfuck (Stream : Stream) (Mem : Memory) (Data : Data) = struct
  type mem = Data.t Mem.t
  type operator = 
    | Simple of (mem -> mem)
    | Complex of (char Stream.t -> mem -> (char Stream.t * mem))

  let jump move incr_char decr_char = 
    let rec aux n st = 
      if Stream.at st = incr_char then
	aux (n+1) (move st)
      else if Stream.at st = decr_char then
	if n = 1 then
	  st
	else
	  aux (n - 1) (move st) 
      else
	aux n (move st)
    in move >| aux 1 >| Stream.next

  let incr_char = '+'
  let decr_char = '-'
  let forward_char = '>'
  let backward_char = '<'
  let prompt_char = ','
  let print_char = '.'
  let jump_forward_char = '['
  let jump_backward_char = ']'
  let jump_forward st mem = 
    (if Mem.get mem = Data.zero then
      jump Stream.next jump_forward_char jump_backward_char st
    else
      Stream.next st), mem

  let jump_backward st mem =
    (if Mem.get mem <> Data.zero then
      jump Stream.prev jump_backward_char jump_forward_char st
    else
      Stream.next st), mem

  let exec = function
    | Simple f -> (fun st mem -> (Stream.next st, f mem))
    | Complex f -> f

  let operators = [
    incr_char, Simple (Mem.update Data.incr);
    decr_char, Simple (Mem.update Data.decr);
    forward_char, Simple Mem.forward;
    backward_char, Simple Mem.backward;
    prompt_char, Simple (fun mem -> Mem.update (const (Data.read ())) mem);
    print_char, Simple (fun mem -> Data.print (Mem.get mem); mem);
    jump_forward_char, Complex jump_forward;
    jump_backward_char, Complex jump_backward;
  ]
  let exec_chan chan = 
    let st = Stream.of_chan chan in
    let rec loop (st, mem) = 
      let c = Stream.at st in
	loop 
	  (try
	     (exec (List.assoc c operators) st mem)
	   with Not_found -> (Stream.next st, mem))
    in loop (st, Mem.single Data.zero)
end

let () = 
  let module MyBrainfuckInterpreter = Brainfuck(Stream)(Zipper)(Int) in
    if Array.length Sys.argv > 1 then begin
      let fd = open_in Sys.argv.(1) in
	(try MyBrainfuckInterpreter.exec_chan fd with _ -> ());
	close_in fd
    end

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAPSTEP 256

struct world {
    unsigned char *map;
    size_t size;
    unsigned char *p;
    struct stack *cond;
};

struct stack {
    struct stack *prev;
    int value;
};

static void grow(struct world *, int);
static void cond_add(struct world *, int);
static void cond_del(struct world *);

static inline void *xmalloc(size_t);
static inline FILE *xfopen(const char *);

int
main(int argc, char *argv[])
{
    long len, i;
    FILE *fpin, *fpget;
    char *p;
    int c;
    struct world w;

    memset(&w, 0, sizeof w);

    if (argc >= 3) {
        fpin = xfopen(argv[1]);
        fpget = xfopen(argv[2]);
    } else if (argc == 2) {
        fpin = xfopen(argv[1]);
        fpget = stdin;
    } else {
        fpin = stdin;
        fpget = stdin;
    }

    fseek(fpin, 0, SEEK_END);
    len = ftell(fpin); /* get the length of the script */

    if (len == -1) {
        fprintf(stderr, "Nothing to read, exiting\n");
        return EXIT_FAILURE;
    }

    fseek(fpin, 0, SEEK_SET);
    p = xmalloc(len * sizeof *p);
    for (i = 0; i < len; i++) {
        c = getc(fpin);
        if (c == EOF) { /* something really weird append. We quit cleanly */
            fprintf(stderr, "EOF received but not expected. Exit.\n");
            free(p);
            return EXIT_FAILURE;
        }
        p[i] = (unsigned char) c;
    }

    /* allocate the map */
    grow(&w, 1);
    w.p = w.map;
    /* now we execute the code */
    for (i = 0; i < len; i++) {
        switch(p[i]) {
        case '>':
            w.p++;
            if (w.p > &w.map[w.size - 1]) /* grow the map */
                grow(&w, 1);
            break;
        case '<':
            if (w.p > w.map)
                w.p--;
            else /* grow the map */
                grow(&w, 0);
            break;
        case '+':
            if (255 == (*w.p))
                *w.p = 0;
            else
                (*w.p)++;
            break;
        case '-':
            if (0 == (*w.p))
                *w.p = 255;
            else
                (*w.p)--;
            break;
        case '.':
            putchar((int) (*w.p));
            break;
        case ',':
            (*w.p) = (unsigned char) getc(fpget);
            break;
        case '[':
            if (0 == (*w.p)) { /* skip the code between [] */
                int k = 1;

                while (k && i < w.size) {
                    i++;
                    if (p[i] == '[')
                        k++;
                    else if (p[i] == ']')
                        k--;
                }
            } else
                cond_add(&w, i);
            break;
        case ']':
            if (!w.cond)
                break;
            if (0 != (*w.p)) /* jump back to the matching [ */
                i = w.cond->value;
            else
                cond_del(&w);
            break;
        default:
            break;
        }
    }
    while (w.cond) {
        fprintf(stderr, "%s: carac %d: No matching ']'\n",
                (argc < 2) ? "stdin" : argv[1], w.cond->value);
        /* print the context 5 lignes before and after */
        for (i = (w.cond->value < 5) ? 0 : w.cond->value - 5;
             i < w.cond->value + 5 && i < w.size; i++)
            putchar(p[i]);
        cond_del(&w);
    }

    free(w.map);
    free(p);

    fclose(fpget);
    fclose(fpin);

    return EXIT_SUCCESS;
}

static void
grow(struct world *w, int after)
{
    size_t oldsize = w->size;

    w->size += MAPSTEP;
    w->map = realloc(w->map, w->size * sizeof *w->map);

    if (after) {
        memset(&w->map[oldsize], 0, MAPSTEP * sizeof *w->map);
        w->p = &w->map[oldsize];
    } else { /* move the old map in the new map's end */
        memmove(&w->map[MAPSTEP], w->map, oldsize);
        memset(w->map, 0, MAPSTEP * sizeof *w->map);
        w->p = &w->map[w->size - oldsize - 1];
    }
}

static void
cond_add(struct world *w, int val)
{
    struct stack *s;

    s = xmalloc(sizeof *s);
    s->prev = w->cond;
    s->value = val;
    w->cond = s;
}

static void
cond_del(struct world *w)
{
    struct stack *s;

    if (w->cond) {
        s = w->cond;
        w->cond = s->prev;
        free(s);
    }
}

static inline void *
xmalloc(size_t n)
{
    void *p;

    p = malloc(n);
    if (!p) {
        fprintf(stderr, "Can't allow more memory. Exiting...\n");
        exit(EXIT_FAILURE);
    }

    return p;
}

static inline FILE *
xfopen(const char *file)
{
    FILE *fp;

    fp = fopen(file, "r");
    if (!fp) {
        perror(file);
        exit(EXIT_FAILURE);
    }

    return fp;
}

Citation : bluestorm

Dark-Side : comment tu gères une mémoire circulaire avec un zipper ?

gcc brainfuck.c --pedantic --ansi -O2 -O3 -Wall
valgrind ./a.out -c helloworld.bf

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <getopt.h>



#define BOUCLE_ERROR 1
#define MALLOC_ERROR 2
#define READING_ERROR 3
#define OPT_ERROR 4

#define F_DEBUG  1
/* stack */
struct stack {
  struct stack *prev;
  int content;
};

struct stack * newStack(){
  struct stack *s = malloc(sizeof(struct stack));
  if (!s){
    fputs("malloc error\n", stderr);
    exit(MALLOC_ERROR);
  }
  return s;
}

void stack_push(struct stack **s, int content){
  struct stack *s2 = newStack();
  s2->prev = *s;
  s2->content = content;
  *s=s2;
}

int stack_pop(struct stack **s){
  struct stack *s2 = (*s);
  int c = s2->content;
  *s=s2->prev;
  free(s2);
  return c;
}

/* liste doublement chainee */
struct mem {
  struct mem *prev, *next;
  unsigned char content;
};

struct mem * newMem(){
  struct mem *m = malloc(sizeof(struct mem));
  if (!m){
    fputs("malloc error\n", stderr);
    exit(MALLOC_ERROR);
  }
  m->prev = NULL;
  m->next = NULL;
  m->content = 0;
  return m;
}

void link_listes(struct mem * prev, struct mem *next){
  prev->next = next;
  next->prev = prev;
}

struct mem * prev(struct mem *m){
  struct mem *p;
  if (m->prev) return m->prev;
  p = newMem();
  link_listes(p, m);
  return p;
}

struct mem * next(struct mem *m){
  struct mem *n;
  if (m->next) return m->next;
  n = newMem();
  link_listes(m, n);
  return n;
}

void freeMem(struct mem *m){
  struct mem *m2, *m3;
  m3=m->next;
  while (m3){
    m2 = m3->next;
    free(m3);
    m3 = m2;
  }
  m3=m->prev;
  while (m3){
    m2 = m3->prev;
    free(m3);
    m3 = m2;
  }
  free(m);
}


int brainfuck(char * code, int len, int flags, FILE *out, FILE * in){
  int i, j;
  struct mem *m = newMem();
  struct stack *s = newStack();
  int * jmps;
  jmps = malloc(len * sizeof(int));
  if (!jmps){
    freeMem(m);
    fputs("malloc error\n", stderr);
    exit(MALLOC_ERROR);
  }
  s->content = -1;
  for(i=0;i<len;i++){
    if (code[i]=='['){
      stack_push(&s, i);
    }else if(code[i]==']'){
      j=stack_pop(&s);
      if ( j == -1 ) return BOUCLE_ERROR;
      jmps[i]=j-1; jmps[j]=i;
    }
  }
  if ( s->content != -1 ) return BOUCLE_ERROR;
  free(s);
  for(i=0;i<len;i++){
    if (flags & F_DEBUG) fprintf(out, "\t %c %d\n", code[i], i);
    switch(code[i]){
      case 0: goto fin;
      case '+': m->content++; break;
      case '-': m->content--; break;
      case '<': m = prev(m); break;
      case '>': m = next(m); break;
      case '.': fputc(m->content, out); break;
      case ',': m->content = fgetc(in); break;
      case '[': if (m->content) break;
        case ']': i=jmps[i]; break;
    }
  }
  fin:
  freeMem(m);
  free(jmps);
  return 0;
}

int main(int argc, char **argv){

  int flags = 0;
  int c;
  FILE *out = stdout;
  FILE *in = stdin;
  FILE *code = NULL;
  size_t length;
  int err;
  char * content;
  while ( (c=getopt(argc, argv, "do:i:c:")) != -1 ){
    switch (c){
      case 'd':
        flags = flags | F_DEBUG;
        break;
      case 'o':
        out = fopen(optarg, "w");
        if (out == NULL){
          fprintf(stderr, "output error (%s)\n", optarg);
          return READING_ERROR;
        }
        break;
      case 'i':
        in = fopen(optarg, "r");
        if (in == NULL){
          fprintf(stderr, "input error (%s)\n", optarg);
          return READING_ERROR;
        }
        break;
      case 'c':
        code = fopen(optarg, "r");
        break;
      case '?':
        if (isprint (optopt))
          fprintf (stderr, "Unknown option `-%c'.\n", optopt);
        else
          fprintf (stderr, "Unknown option character `\\x%x'.\n", optopt);
        return OPT_ERROR;
      default:
        abort ();
    }
  }
  if (code == NULL){
    fputs("code file error\n", stderr);
    exit(1);
  }
  fseek(code, 0, SEEK_END);
  length=ftell(code);
  content=malloc(length);
  if (!content){
    fputs("malloc error\n", stderr);
    return MALLOC_ERROR;
  }
  fseek(code, 0, SEEK_SET);
  c = fread (content,1,length,code);
  fclose(code);
  if (c != length) {
    fputs("Reading error\n", stderr);
    return READING_ERROR;
  }
  if ( (err=brainfuck(content, length, flags, out, in)) ){
    fprintf(stderr, "erreur (%d)\n", err);
    return err;
  }
  free(content);
  return 0;
}

Citation : bluestorm

Dark-Side : comment tu gères une mémoire circulaire avec un zipper ?

Citation : sisco

Bonjour à tous,

Désolé, je ne suis pas capable de faire quelque chose, je n'ai pas le niveau. En revanche, il y a un code que je n'arrive pas à faire fonctionner ou j'ai mal compris un truc, ce qui est fort possible. C'est le code Python de wgmpgp.

À wgmpgp : Que doit-il se passer une fois qu'on a lancé le script en ligne de commande. Personnellement, j'ai des nombres grandissant qui s'affichent indéfiniment. J'imagine que ce n'est pas le comportement voulu pour un interpréteur, non ?

Merci d'avance.

code = '''++++++++++
[                 
   >+++++++>++++++++++>+++>+<<<<-
]
                 
>++.                     
>+.                     
+++++++.                
.                         
+++.                      
>++.                      
<<+++++++++++++++.        
>.                        
+++.                      
------.                   
--------.                 
>+.                       
>.      
]'''

++++++++++
[                 
   >+++++++>++++++++++>+++>+<<<<-
]
                 
>++.                     
>+.                     
+++++++.                
.                         
+++.                      
>++.                      
<<+++++++++++++++.        
>.                        
+++.                      
------.                   
--------.                 
>+.                       
>.