[brainfuck.git] / bf.c

/* depend: */
/* cflags: */
/* linker: debug.o */
/* winlnk: debug.o */
/* doslnk: debug.o */

#include <errno.h>
#include <getopt.h>
#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "debug.h"

/* macros */

#define BUFSIZE 256
#define MAXJUMP 4
#define MEMSIZE 10

#define CHECKALLOC(ptr) \
    do { \
        if ((ptr) == NULL) { \
            VERBOSE (ERROR, fprintf (stderr, "can't get enough memory for '%s'\n", #ptr)); \
            exit (1); \
        } \
    } while (0)

/* type definition */

/* gobal variables */

char *progname = NULL;
int p = 0;
signed char mem[MEMSIZE] = {0};
int j = 0;
int jump[MAXJUMP] = {0};

/* help function */

int usage (int ret)
{
    FILE *fd = ret ? stderr : stdout;
    fprintf (fd, "usage: %s [-i file] [-h] [-m memory] [-o file] [-v]\n", progname);
    fprintf (fd, " -i : input file\n");
    fprintf (fd, " -h : help message\n");
    fprintf (fd, " -m : memory [0..0]\n");
    fprintf (fd, " -o : output file\n");
    fprintf (fd, " -v : verbose level (%d)\n", verbose);

    return ret;
}

/* main process */

int process (char *buffer, int nb, FILE *out) {

    for (int i = 0; i < nb; i++) {
        if (buffer[i] == 0) {
            break;
        }

        VERBOSE (DEBUG, fprintf (stderr, "%s: p=%d, buffer='%s', memory=[ ", progname, p, buffer + i); for (int _i = 0; _i < MEMSIZE; _i++) fprintf (stderr," %d", mem[_i]); fprintf (stderr," ]\n"));

        switch (buffer[i]) {
            case '>': /* increase pointer */
                p++;
                break;
            case '<': /* decrease pointer */
                p--;
                break;
            case '+': /* increase pointer value */
                if ((p >= 0) && (p < MEMSIZE)) {
                    mem[p]++;
                } else {
                    VERBOSE (ERROR, fprintf (stderr, "%s: invalid address (%d)\n", progname, p));
                    return 1;
                }
                break;
            case '-': /* decrease pointer value */
                if ((p >= 0) && (p < MEMSIZE)) {
                    mem[p]--;
                } else {
                    VERBOSE (ERROR, fprintf (stderr, "%s: invalid address (%d)\n", progname, p));
                    return 1;
                }
                break;
            case '.': /* output pointer value */
                if ((p >= 0) && (p < MEMSIZE)) {
                    fprintf (out, "%c", mem[p]);
                } else {
                    VERBOSE (ERROR, fprintf (stderr, "%s: invalid address (%d)\n", progname, p));
                    return 1;
                }
                break;
            case ',': /* read a byte and store it in memory */
                if ((p >= 0) && (p < MEMSIZE)) {
                    int c = getchar ();
                    mem[p] = (c > 0) ? c : 0;
                } else {
                    VERBOSE (ERROR, fprintf (stderr, "%s: invalid address (%d)\n", progname, p));
                    return 1;
                }
                break;
            case '[': /* jump to right bracket if pointer is set to 0 */
                if ((p < 0) || (p >= MEMSIZE)) {
                    VERBOSE (ERROR, fprintf (stderr, "%s: invalid address (%d)\n", progname, p));
                    return 1;
                }
                if (mem[p] == 0) {
                    int bracket = 1;
                    while ((++i < nb) && (bracket > 0)) {
                        bracket += (buffer[i] == '[') ? +1 : (buffer[i] == ']') ? -1 :0;
                    }
                    if (bracket) {
                        VERBOSE (ERROR, fprintf (stderr, "%s: brace not closed\n", progname));
                        return 1;
                    }
                    i--;
                } else {
                    if (j >= MAXJUMP) {
                        VERBOSE (ERROR, fprintf (stderr, "%s: too many jump\n", progname));
                        return 1;
                    }
                    jump[j++] = i;
                }
                break;
            case ']': /* jump to left bracket if pointer is different to 0 */
                if (j <= 0) {
                    VERBOSE (ERROR, fprintf (stderr, "%s: can't jump back\n", progname));
                    return 1;
                }
                i = jump[--j] - 1;
                break;
            case ' ':
            case '\t':
            case '\n':
            case '\r':
                break;
            default:
                VERBOSE (WARNING, fprintf (stderr, "%s: can't understand '%c'\n", progname, buffer[i]));
        }
        
        //VERBOSE (DEBUG, fprintf (stderr, "%s: p: %d mem:", progname, p); for (int _i = 0; _i < MEMSIZE; _i++) fprintf (stderr, " %d", mem[_i]); fprintf (stderr, "\n"));

    }

    return 0;
}

/* main function */

int main (int argc, char *argv[]) 
{
    char *input = NULL;
    char *output = NULL;
    char *buffer = NULL;
    int n = 0;
    int size = 0;
    FILE *fid = NULL;

    /* get basename */
    char *pt = progname = argv[0];
    while (*pt) {
        if ((*pt == '/') || (*pt == '\\')) {
           progname = pt + 1;
        }
        pt++;
    }

    int c;
    while ((c = getopt(argc, argv, "e:i:m:o:hv:")) != EOF) {
        switch (c) {
        case 'e':
            free (buffer);
            buffer = strdup (optarg);
            CHECKALLOC (buffer);
            size = strlen (buffer) + 1;
            break;
        case 'i':
            input = optarg;
            break;
        case 'm':
            for (int i = 0; i < MEMSIZE; i++) {
                if (optarg) {
                    mem[i] = strtol (optarg, &optarg, 10);
                    VERBOSE (DEBUG, fprintf (stderr, "%s: mem[%d] = %d\n", progname, i, mem[i]));
                }
            }
            if (*optarg != 0) {
                VERBOSE (WARNING, fprintf (stderr, "%s: too many memory values or incorrect value\n", progname));
                free (buffer);
                return 1;
            }
            break;
        case 'o':
            output = optarg;
            break;
        case 'v':
            verbose = atoi (optarg);
            break;
        case 'h':
        default:
            free (buffer);
            return usage (c != 'h');
        }
    }
    if (argc - optind != 0) {
        VERBOSE (ERROR, fprintf (stderr, "%s: invalid option -- %s\n", progname, argv[optind]));
        free (buffer);
        return usage (1);
    }

    /* check input file */
    if (input) {
        fid = fopen (input, "r");
        if (fid == NULL) {
            VERBOSE (ERROR, fprintf (stderr, "%s: can't open file '%s' for reading\n", progname, input));
            free (buffer);
            return 1;
        }
    } else if (buffer == NULL) {
        fid = stdin;
    }

    /* read input file */
    if (fid) {
        while (!feof (fid)) {
            buffer = (char *) realloc (buffer, size + BUFSIZE);
            CHECKALLOC (buffer);
            memset (buffer + size, 0, BUFSIZE);
            n = fread (buffer + size, 1, BUFSIZE, fid);
            if (ferror (fid)) {
                VERBOSE (ERROR, fprintf (stderr, "%s: can't read data from file '%s'\n", progname, input));
                if (fid != stdin) {
                    fclose (fid);
                }
                free (buffer);
                return 1;
            }
            size += BUFSIZE;
        }

        if (fid != stdin) {
            fclose (fid);
        }
        VERBOSE (DEBUG, fprintf (stderr, "%s: read %d bytes\n", progname, size + n - BUFSIZE));
    } else {
        VERBOSE (DEBUG, fprintf (stderr, "%s: prog %d bytes\n", progname, size -1));
    }

    /* check output file */
    if (output) {
        fid = fopen (output, "w");
        if (fid == NULL) {
            VERBOSE (ERROR, fprintf (stderr, "%s: can't open file '%s' for writing\n", progname, output));
            free (buffer);
            return 1;
        }
    } else {
        fid = stdout;
    }

    /* main process */
    int rc = process (buffer, size, fid);

    /* close output file */
    if (fid != stdout) {
        fclose (fid);
    }


    VERBOSE (INFO, fprintf (stdout, "\nmemory:"); for (int _i = 0; _i < MEMSIZE; _i++) fprintf (stdout," %d", (int)mem[_i]); fprintf (stdout,"\n"));

    free (buffer);
    return rc;
}

// test: bf.exe -h
// test: bf.exe -h | awk '/usage:/ { rc=1 } END { exit (1-rc) }'

// test: bf.exe -_ 2> /dev/null | awk 'END { if (NR == 0) { exit(0) } else exit (1) }'
// test: bf.exe -_ 2>&1 | awk '/usage:/ { rc=1 } END { exit (1-rc) }'
// test: bf.exe error 2>&1 | awk '/usage:/ { rc=1 } END { exit (1-rc) }'

// test: bf.exe -i error.b 2>&1 | grep "can't open" | grep -q "reading"
// test: echo ">>." | bf.exe -o error/error.b 2>&1 | grep "can't open" | grep -q "writing"
// test: echo "error" | bf.exe -v1 2>&1 | grep -q "can't understand"
// test: echo "<+" | bf.exe -v1 2>&1 | grep -q "invalid address"
// test: echo "<-" | bf.exe -v1 2>&1 | grep -q "invalid address"
// test: echo "<." | bf.exe -v1 2>&1 | grep -q "invalid address"
// test: echo "<," | bf.exe -v1 2>&1 | grep -q "invalid address"
// test: echo "<[" | bf.exe -v1 2>&1 | grep -q "invalid address"
// test: echo "[" | bf.exe -v1 2>&1 | grep -q "brace not closed"
// test: echo "+[[[[[]]]]]" | bf.exe -v1 2>&1 | grep -q "too many jump"
// test: bf.exe -m "0 1 2 3 4 5 6 7 8 9 10" -e '.' -v1 2>&1 | grep -q "too many memory values"
// test: bf.exe -m "0 error" -e '.' -v1 2>&1 | grep -q "incorrect value"
// test: echo "]" | bf.exe -v1 2>&1 | grep -q "can't jump back"

// test: echo '+++>++>>-<--' | bf.exe -v2 | grep -q "memory: 3 2 -2 -1 0"
// test: bf.exe -e '+++' -e '+++>++>>-<--' -v2 | grep -q "memory: 3 2 -2 -1 0"
// test: bf.exe -e '+++>++>>-<--' -v2 | grep -q "memory: 3 2 -2 -1 0"
// test: bf.exe -m "51 50 49" -e '.>.>.' |grep -q "321"
// test: bf.exe -m "51 50 49" -e '.>.>.' -o test.log && grep -q "321" test.log; rc=$?; rm test.log; test $rc -eq 0
// test: echo '+++>++>>-<--' > test.b; bf.exe -i test.b | grep -q "memory: 3 2 -2 -1 0"; rc=$?; rm test.b; test $rc -eq 0

// test: echo '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.' | bf.exe -v1 | grep -q "Hello World!"
// test: echo '++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++++++++++++++.>+++++++++++++++++.<<++.>+++++++++++++.>--.<<.>+++.+.--.>----.++++++.+.<++.>----.++.<<.>>+.-------.<<.>>++.<.>+++++.<<.>-.+.<.>---.>---.<-.++++++++.>----.<---.>+++++++.<---.++++++++.' | bf.exe -v1 | grep -q "Tu as decouvert un peu de brainfuck"

// test: echo -e "123\0" | bf.exe -e ',[>,]' -v2 | grep -q "memory: 49 50 51 0"
// test: echo -e "4+3\0" | bf.exe -e ',>++++++[<-------->-],,[<+>-]<.' -v1 | grep -q 7
// test: echo -e "1+7\0" | bf.exe -e ',>++++++[<-------->-],,[<+>-]<.' -v1 | grep -q 8
// test: echo -e "3*2\0" | bf.exe -e ',>,,>++++++++[<------<------>>-]<<[>[>+>+<<-]>>[<<+>>-]<<<-]>>>++++++[<++++++++>-]<.' -v1 | grep -q 6
// test: echo -e "1*7\0" | bf.exe -e ',>,,>++++++++[<------<------>>-]<<[>[>+>+<<-]>>[<<+>>-]<<<-]>>>++++++[<++++++++>-]<.' -v1 | grep -q 7

/* vim: set ts=4 sw=4 et: */
Commit	Line	Data
	1	/* depend: */
	2	/* cflags: */
	3	/* linker: debug.o */
	4	/* winlnk: debug.o */
	5	/* doslnk: debug.o */
	6
	7	#include <errno.h>
	8	#include <getopt.h>
	9	#include <malloc.h>
	10	#include <stdio.h>
	11	#include <stdlib.h>
	12	#include <string.h>
	13
	14	#include "debug.h"
	15
	16	/* macros */
	17
	18	#define BUFSIZE 256
	19	#define MAXJUMP 4
	20	#define MEMSIZE 10
	21
	22	#define CHECKALLOC(ptr) \
	23	do { \
	24	if ((ptr) == NULL) { \
	25	VERBOSE (ERROR, fprintf (stderr, "can't get enough memory for '%s'\n", #ptr)); \
	26	exit (1); \
	27	} \
	28	} while (0)
	29
	30	/* type definition */
	31
	32	/* gobal variables */
	33
	34	char *progname = NULL;
	35	int p = 0;
	36	signed char mem[MEMSIZE] = {0};
	37	int j = 0;
	38	int jump[MAXJUMP] = {0};
	39
	40	/* help function */
	41
	42	int usage (int ret)
	43	{
	44	FILE *fd = ret ? stderr : stdout;
	45	fprintf (fd, "usage: %s [-i file] [-h] [-m memory] [-o file] [-v]\n", progname);
	46	fprintf (fd, " -i : input file\n");
	47	fprintf (fd, " -h : help message\n");
	48	fprintf (fd, " -m : memory [0..0]\n");
	49	fprintf (fd, " -o : output file\n");
	50	fprintf (fd, " -v : verbose level (%d)\n", verbose);
	51
	52	return ret;
	53	}
	54
	55	/* main process */
	56
	57	int process (char buffer, int nb, FILE out) {
	58
	59	for (int i = 0; i < nb; i++) {
	60	if (buffer[i] == 0) {
	61	break;
	62	}
	63
	64	VERBOSE (DEBUG, fprintf (stderr, "%s: p=%d, buffer='%s', memory=[ ", progname, p, buffer + i); for (int _i = 0; _i < MEMSIZE; _i++) fprintf (stderr," %d", mem[_i]); fprintf (stderr," ]\n"));
	65
	66	switch (buffer[i]) {
	67	case '>': /* increase pointer */
	68	p++;
	69	break;
	70	case '<': /* decrease pointer */
	71	p--;
	72	break;
	73	case '+': /* increase pointer value */
	74	if ((p >= 0) && (p < MEMSIZE)) {
	75	mem[p]++;
	76	} else {
	77	VERBOSE (ERROR, fprintf (stderr, "%s: invalid address (%d)\n", progname, p));
	78	return 1;
	79	}
	80	break;
	81	case '-': /* decrease pointer value */
	82	if ((p >= 0) && (p < MEMSIZE)) {
	83	mem[p]--;
	84	} else {
	85	VERBOSE (ERROR, fprintf (stderr, "%s: invalid address (%d)\n", progname, p));
	86	return 1;
	87	}
	88	break;
	89	case '.': /* output pointer value */
	90	if ((p >= 0) && (p < MEMSIZE)) {
	91	fprintf (out, "%c", mem[p]);
	92	} else {
	93	VERBOSE (ERROR, fprintf (stderr, "%s: invalid address (%d)\n", progname, p));
	94	return 1;
	95	}
	96	break;
	97	case ',': /* read a byte and store it in memory */
	98	if ((p >= 0) && (p < MEMSIZE)) {
	99	int c = getchar ();
	100	mem[p] = (c > 0) ? c : 0;
	101	} else {
	102	VERBOSE (ERROR, fprintf (stderr, "%s: invalid address (%d)\n", progname, p));
	103	return 1;
	104	}
	105	break;
	106	case '[': /* jump to right bracket if pointer is set to 0 */
	107	if ((p < 0) \|\| (p >= MEMSIZE)) {
	108	VERBOSE (ERROR, fprintf (stderr, "%s: invalid address (%d)\n", progname, p));
	109	return 1;
	110	}
	111	if (mem[p] == 0) {
	112	int bracket = 1;
	113	while ((++i < nb) && (bracket > 0)) {
	114	bracket += (buffer[i] == '[') ? +1 : (buffer[i] == ']') ? -1 :0;
	115	}
	116	if (bracket) {
	117	VERBOSE (ERROR, fprintf (stderr, "%s: brace not closed\n", progname));
	118	return 1;
	119	}
	120	i--;
	121	} else {
	122	if (j >= MAXJUMP) {
	123	VERBOSE (ERROR, fprintf (stderr, "%s: too many jump\n", progname));
	124	return 1;
	125	}
	126	jump[j++] = i;
	127	}
	128	break;
	129	case ']': /* jump to left bracket if pointer is different to 0 */
	130	if (j <= 0) {
	131	VERBOSE (ERROR, fprintf (stderr, "%s: can't jump back\n", progname));
	132	return 1;
	133	}
	134	i = jump[--j] - 1;
	135	break;
	136	case ' ':
	137	case '\t':
	138	case '\n':
	139	case '\r':
	140	break;
	141	default:
	142	VERBOSE (WARNING, fprintf (stderr, "%s: can't understand '%c'\n", progname, buffer[i]));
	143	}
	144
	145	//VERBOSE (DEBUG, fprintf (stderr, "%s: p: %d mem:", progname, p); for (int _i = 0; _i < MEMSIZE; _i++) fprintf (stderr, " %d", mem[_i]); fprintf (stderr, "\n"));
	146
	147	}
	148
	149	return 0;
	150	}
	151
	152	/* main function */
	153
	154	int main (int argc, char *argv[])
	155	{
	156	char *input = NULL;
	157	char *output = NULL;
	158	char *buffer = NULL;
	159	int n = 0;
	160	int size = 0;
	161	FILE *fid = NULL;
	162
	163	/* get basename */
	164	char *pt = progname = argv[0];
	165	while (*pt) {
	166	if ((pt == '/') \|\| (pt == '\\')) {
	167	progname = pt + 1;
	168	}
	169	pt++;
	170	}
	171
	172	int c;
	173	while ((c = getopt(argc, argv, "e:i:m:o:hv:")) != EOF) {
	174	switch (c) {
	175	case 'e':
	176	free (buffer);
	177	buffer = strdup (optarg);
	178	CHECKALLOC (buffer);
	179	size = strlen (buffer) + 1;
	180	break;
	181	case 'i':
	182	input = optarg;
	183	break;
	184	case 'm':
	185	for (int i = 0; i < MEMSIZE; i++) {
	186	if (optarg) {
	187	mem[i] = strtol (optarg, &optarg, 10);
	188	VERBOSE (DEBUG, fprintf (stderr, "%s: mem[%d] = %d\n", progname, i, mem[i]));
	189	}
	190	}
	191	if (*optarg != 0) {
	192	VERBOSE (WARNING, fprintf (stderr, "%s: too many memory values or incorrect value\n", progname));
	193	free (buffer);
	194	return 1;
	195	}
	196	break;
	197	case 'o':
	198	output = optarg;
	199	break;
	200	case 'v':
	201	verbose = atoi (optarg);
	202	break;
	203	case 'h':
	204	default:
	205	free (buffer);
	206	return usage (c != 'h');
	207	}
	208	}
	209	if (argc - optind != 0) {
	210	VERBOSE (ERROR, fprintf (stderr, "%s: invalid option -- %s\n", progname, argv[optind]));
	211	free (buffer);
	212	return usage (1);
	213	}
	214
	215	/* check input file */
	216	if (input) {
	217	fid = fopen (input, "r");
	218	if (fid == NULL) {
	219	VERBOSE (ERROR, fprintf (stderr, "%s: can't open file '%s' for reading\n", progname, input));
	220	free (buffer);
	221	return 1;
	222	}
	223	} else if (buffer == NULL) {
	224	fid = stdin;
	225	}
	226
	227	/* read input file */
	228	if (fid) {
	229	while (!feof (fid)) {
	230	buffer = (char *) realloc (buffer, size + BUFSIZE);
	231	CHECKALLOC (buffer);
	232	memset (buffer + size, 0, BUFSIZE);
	233	n = fread (buffer + size, 1, BUFSIZE, fid);
	234	if (ferror (fid)) {
	235	VERBOSE (ERROR, fprintf (stderr, "%s: can't read data from file '%s'\n", progname, input));
	236	if (fid != stdin) {
	237	fclose (fid);
	238	}
	239	free (buffer);
	240	return 1;
	241	}
	242	size += BUFSIZE;
	243	}
	244
	245	if (fid != stdin) {
	246	fclose (fid);
	247	}
	248	VERBOSE (DEBUG, fprintf (stderr, "%s: read %d bytes\n", progname, size + n - BUFSIZE));
	249	} else {
	250	VERBOSE (DEBUG, fprintf (stderr, "%s: prog %d bytes\n", progname, size -1));
	251	}
	252
	253	/* check output file */
	254	if (output) {
	255	fid = fopen (output, "w");
	256	if (fid == NULL) {
	257	VERBOSE (ERROR, fprintf (stderr, "%s: can't open file '%s' for writing\n", progname, output));
	258	free (buffer);
	259	return 1;
	260	}
	261	} else {
	262	fid = stdout;
	263	}
	264
	265	/* main process */
	266	int rc = process (buffer, size, fid);
	267
	268	/* close output file */
	269	if (fid != stdout) {
	270	fclose (fid);
	271	}
	272
	273
	274	VERBOSE (INFO, fprintf (stdout, "\nmemory:"); for (int _i = 0; _i < MEMSIZE; _i++) fprintf (stdout," %d", (int)mem[_i]); fprintf (stdout,"\n"));
	275
	276	free (buffer);
	277	return rc;
	278	}
	279
	280	// test: bf.exe -h
	281	// test: bf.exe -h \| awk '/usage:/ { rc=1 } END { exit (1-rc) }'
	282
	283	// test: bf.exe -_ 2> /dev/null \| awk 'END { if (NR == 0) { exit(0) } else exit (1) }'
	284	// test: bf.exe -_ 2>&1 \| awk '/usage:/ { rc=1 } END { exit (1-rc) }'
	285	// test: bf.exe error 2>&1 \| awk '/usage:/ { rc=1 } END { exit (1-rc) }'
	286
	287	// test: bf.exe -i error.b 2>&1 \| grep "can't open" \| grep -q "reading"
	288	// test: echo ">>." \| bf.exe -o error/error.b 2>&1 \| grep "can't open" \| grep -q "writing"
	289	// test: echo "error" \| bf.exe -v1 2>&1 \| grep -q "can't understand"
	290	// test: echo "<+" \| bf.exe -v1 2>&1 \| grep -q "invalid address"
	291	// test: echo "<-" \| bf.exe -v1 2>&1 \| grep -q "invalid address"
	292	// test: echo "<." \| bf.exe -v1 2>&1 \| grep -q "invalid address"
	293	// test: echo "<," \| bf.exe -v1 2>&1 \| grep -q "invalid address"
	294	// test: echo "<[" \| bf.exe -v1 2>&1 \| grep -q "invalid address"
	295	// test: echo "[" \| bf.exe -v1 2>&1 \| grep -q "brace not closed"
	296	// test: echo "+[[[[[]]]]]" \| bf.exe -v1 2>&1 \| grep -q "too many jump"
	297	// test: bf.exe -m "0 1 2 3 4 5 6 7 8 9 10" -e '.' -v1 2>&1 \| grep -q "too many memory values"
	298	// test: bf.exe -m "0 error" -e '.' -v1 2>&1 \| grep -q "incorrect value"
	299	// test: echo "]" \| bf.exe -v1 2>&1 \| grep -q "can't jump back"
	300
	301	// test: echo '+++>++>>-<--' \| bf.exe -v2 \| grep -q "memory: 3 2 -2 -1 0"
	302	// test: bf.exe -e '+++' -e '+++>++>>-<--' -v2 \| grep -q "memory: 3 2 -2 -1 0"
	303	// test: bf.exe -e '+++>++>>-<--' -v2 \| grep -q "memory: 3 2 -2 -1 0"
	304	// test: bf.exe -m "51 50 49" -e '.>.>.' \|grep -q "321"
	305	// test: bf.exe -m "51 50 49" -e '.>.>.' -o test.log && grep -q "321" test.log; rc=$?; rm test.log; test $rc -eq 0
	306	// test: echo '+++>++>>-<--' > test.b; bf.exe -i test.b \| grep -q "memory: 3 2 -2 -1 0"; rc=$?; rm test.b; test $rc -eq 0
	307
	308	// test: echo '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.' \| bf.exe -v1 \| grep -q "Hello World!"
	309	// test: echo '++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++++++++++++++.>+++++++++++++++++.<<++.>+++++++++++++.>--.<<.>+++.+.--.>----.++++++.+.<++.>----.++.<<.>>+.-------.<<.>>++.<.>+++++.<<.>-.+.<.>---.>---.<-.++++++++.>----.<---.>+++++++.<---.++++++++.' \| bf.exe -v1 \| grep -q "Tu as decouvert un peu de brainfuck"
	310
	311	// test: echo -e "123\0" \| bf.exe -e ',[>,]' -v2 \| grep -q "memory: 49 50 51 0"
	312	// test: echo -e "4+3\0" \| bf.exe -e ',>++++++[<-------->-],,[<+>-]<.' -v1 \| grep -q 7
	313	// test: echo -e "1+7\0" \| bf.exe -e ',>++++++[<-------->-],,[<+>-]<.' -v1 \| grep -q 8
	314	// test: echo -e "3*2\0" \| bf.exe -e ',>,,>++++++++[<------<------>>-]<<[>[>+>+<<-]>>[<<+>>-]<<<-]>>>++++++[<++++++++>-]<.' -v1 \| grep -q 6
	315	// test: echo -e "1*7\0" \| bf.exe -e ',>,,>++++++++[<------<------>>-]<<[>[>+>+<<-]>>[<<+>>-]<<<-]>>>++++++[<++++++++>-]<.' -v1 \| grep -q 7
	316
	317	/* vim: set ts=4 sw=4 et: */