[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
048e6e55 LM	1	/* depend: */
	2	/* cflags: */
	3	/* linker: debug.o */
bd9ffcf2 LM	4	/* winlnk: debug.o */
bd9ffcf2 LM	5	/* doslnk: debug.o */
048e6e55	6
a213b0ae	7	#include <errno.h>
048e6e55 LM	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
3d8520e3 LM	19	#define MAXJUMP 4
3d8520e3 LM	20	#define MEMSIZE 10
048e6e55	21
72c52012 LM	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
048e6e55 LM	30	/* type definition */
	31
	32	/* gobal variables */
	33
	34	char *progname = NULL;
	35	int p = 0;
6ab28783	36	signed char mem[MEMSIZE] = {0};
3d8520e3 LM	37	int j = 0;
3d8520e3 LM	38	int jump[MAXJUMP] = {0};
048e6e55 LM	39
	40	/* help function */
	41
	42	int usage (int ret)
	43	{
	44	FILE *fd = ret ? stderr : stdout;
e07f5d2a	45	fprintf (fd, "usage: %s [-i file] [-h] [-m memory] [-o file] [-v]\n", progname);
048e6e55 LM	46	fprintf (fd, " -i : input file\n");
048e6e55 LM	47	fprintf (fd, " -h : help message\n");
e07f5d2a	48	fprintf (fd, " -m : memory [0..0]\n");
048e6e55 LM	49	fprintf (fd, " -o : output file\n");
	50	fprintf (fd, " -v : verbose level (%d)\n", verbose);
	51
	52	return ret;
	53	}
	54
07cc2c73 LM	55	/* main process */
	56
	57	int process (char buffer, int nb, FILE out) {
07cc2c73	58
04c960d9	59	for (int i = 0; i < nb; i++) {
3d8520e3 LM	60	if (buffer[i] == 0) {
	61	break;
	62	}
	63
04c960d9	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"));
07cc2c73	65
07cc2c73 LM	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)) {
096fb1e3 LM	99	int c = getchar ();
096fb1e3 LM	100	mem[p] = (c > 0) ? c : 0;
07cc2c73 LM	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 */
3d8520e3 LM	107	if ((p < 0) \|\| (p >= MEMSIZE)) {
	108	VERBOSE (ERROR, fprintf (stderr, "%s: invalid address (%d)\n", progname, p));
	109	return 1;
	110	}
07cc2c73 LM	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	}
3d8520e3	120	i--;
07cc2c73	121	} else {
3d8520e3 LM	122	if (j >= MAXJUMP) {
	123	VERBOSE (ERROR, fprintf (stderr, "%s: too many jump\n", progname));
	124	return 1;
	125	}
	126	jump[j++] = i;
07cc2c73 LM	127	}
	128	break;
	129	case ']': /* jump to left bracket if pointer is different to 0 */
3d8520e3 LM	130	if (j <= 0) {
	131	VERBOSE (ERROR, fprintf (stderr, "%s: can't jump back\n", progname));
	132	return 1;
07cc2c73	133	}
3d8520e3	134	i = jump[--j] - 1;
07cc2c73	135	break;
096fb1e3 LM	136	case ' ':
096fb1e3 LM	137	case '\t':
07cc2c73 LM	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
04c960d9	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"));
07cc2c73 LM	146
	147	}
	148
	149	return 0;
	150	}
	151
048e6e55 LM	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;
096fb1e3	173	while ((c = getopt(argc, argv, "e:i:m:o:hv:")) != EOF) {
048e6e55	174	switch (c) {
096fb1e3	175	case 'e':
04c960d9	176	free (buffer);
096fb1e3	177	buffer = strdup (optarg);
72c52012	178	CHECKALLOC (buffer);
096fb1e3 LM	179	size = strlen (buffer) + 1;
096fb1e3 LM	180	break;
048e6e55 LM	181	case 'i':
	182	input = optarg;
	183	break;
e07f5d2a	184	case 'm':
04c960d9	185	for (int i = 0; i < MEMSIZE; i++) {
e07f5d2a LM	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) {
32237385	192	VERBOSE (WARNING, fprintf (stderr, "%s: too many memory values or incorrect value\n", progname));
04c960d9	193	free (buffer);
e07f5d2a LM	194	return 1;
	195	}
	196	break;
048e6e55 LM	197	case 'o':
	198	output = optarg;
	199	break;
	200	case 'v':
	201	verbose = atoi (optarg);
	202	break;
	203	case 'h':
	204	default:
04c960d9	205	free (buffer);
048e6e55 LM	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]));
04c960d9	211	free (buffer);
048e6e55 LM	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));
04c960d9	220	free (buffer);
048e6e55 LM	221	return 1;
048e6e55 LM	222	}
096fb1e3	223	} else if (buffer == NULL) {
048e6e55 LM	224	fid = stdin;
	225	}
	226
	227	/* read input file */
096fb1e3 LM	228	if (fid) {
	229	while (!feof (fid)) {
	230	buffer = (char *) realloc (buffer, size + BUFSIZE);
72c52012	231	CHECKALLOC (buffer);
096fb1e3 LM	232	memset (buffer + size, 0, BUFSIZE);
096fb1e3 LM	233	n = fread (buffer + size, 1, BUFSIZE, fid);
04c960d9	234	if (ferror (fid)) {
096fb1e3	235	VERBOSE (ERROR, fprintf (stderr, "%s: can't read data from file '%s'\n", progname, input));
04c960d9 LM	236	if (fid != stdin) {
	237	fclose (fid);
	238	}
	239	free (buffer);
096fb1e3 LM	240	return 1;
	241	}
	242	size += BUFSIZE;
048e6e55	243	}
048e6e55	244
3d8520e3 LM	245	if (fid != stdin) {
	246	fclose (fid);
	247	}
096fb1e3 LM	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	}
048e6e55 LM	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));
04c960d9	258	free (buffer);
048e6e55 LM	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 */
3d8520e3 LM	269	if (fid != stdout) {
	270	fclose (fid);
	271	}
	272
a213b0ae	273
04c960d9	274	VERBOSE (INFO, fprintf (stdout, "\nmemory:"); for (int _i = 0; _i < MEMSIZE; _i++) fprintf (stdout," %d", (int)mem[_i]); fprintf (stdout,"\n"));
048e6e55	275
04c960d9	276	free (buffer);
048e6e55 LM	277	return rc;
	278	}
	279
048e6e55 LM	280	// test: bf.exe -h
048e6e55 LM	281	// test: bf.exe -h \| awk '/usage:/ { rc=1 } END { exit (1-rc) }'
32237385	282
048e6e55 LM	283	// test: bf.exe -_ 2> /dev/null \| awk 'END { if (NR == 0) { exit(0) } else exit (1) }'
048e6e55 LM	284	// test: bf.exe -_ 2>&1 \| awk '/usage:/ { rc=1 } END { exit (1-rc) }'
32237385 LM	285	// test: bf.exe error 2>&1 \| awk '/usage:/ { rc=1 } END { exit (1-rc) }'
32237385 LM	286
096fb1e3 LM	287	// test: bf.exe -i error.b 2>&1 \| grep "can't open" \| grep -q "reading"
096fb1e3 LM	288	// test: echo ">>." \| bf.exe -o error/error.b 2>&1 \| grep "can't open" \| grep -q "writing"
32237385 LM	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
096fb1e3	301	// test: echo '+++>++>>-<--' \| bf.exe -v2 \| grep -q "memory: 3 2 -2 -1 0"
32237385	302	// test: bf.exe -e '+++' -e '+++>++>>-<--' -v2 \| grep -q "memory: 3 2 -2 -1 0"
096fb1e3	303	// test: bf.exe -e '+++>++>>-<--' -v2 \| grep -q "memory: 3 2 -2 -1 0"
3d8520e3	304	// test: bf.exe -m "51 50 49" -e '.>.>.' \|grep -q "321"
20c60362	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
ee55e48c	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
32237385	307
e07f5d2a LM	308	// test: echo '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.' \| bf.exe -v1 \| grep -q "Hello World!"
e07f5d2a LM	309	// test: echo '++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++++++++++++++.>+++++++++++++++++.<<++.>+++++++++++++.>--.<<.>+++.+.--.>----.++++++.+.<++.>----.++.<<.>>+.-------.<<.>>++.<.>+++++.<<.>-.+.<.>---.>---.<-.++++++++.>----.<---.>+++++++.<---.++++++++.' \| bf.exe -v1 \| grep -q "Tu as decouvert un peu de brainfuck"
32237385	310
096fb1e3	311	// test: echo -e "123\0" \| bf.exe -e ',[>,]' -v2 \| grep -q "memory: 49 50 51 0"
3d8520e3 LM	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
048e6e55 LM	316
048e6e55 LM	317	/* vim: set ts=4 sw=4 et: */