initial version

[brainfuck.git] / bf.c

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

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

#include "debug.h"

/* macros */

#define BUFSIZE 256
#define MEMSIZE 10

/* type definition */

/* gobal variables */

char *progname = NULL;
int p = 0;
char mem[MEMSIZE] = {0};

/* help function */

int usage (int ret)
{
    FILE *fd = ret ? stderr : stdout;
    fprintf (fd, "usage: %s [-i file] [-h] [-m k&r|ansi|c99] [-o file] [-v]\n", progname);
    fprintf (fd, " -i : input file\n");
    fprintf (fd, " -h : help message\n");
    fprintf (fd, " -m : indent mode\n");
    fprintf (fd, " -o : output file\n");
    fprintf (fd, " -v : verbose level (%d)\n", verbose);

    return ret;
}

/* 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, "i:o:hv:")) != EOF) {
        switch (c) {
        case 'i':
            input = optarg;
            break;
        case 'o':
            output = optarg;
            break;
        case 'v':
            verbose = atoi (optarg);
            break;
        case 'h':
        default:
            return usage (c != 'h');
        }
    }
    if (argc - optind != 0) {
        VERBOSE (ERROR, fprintf (stderr, "%s: invalid option -- %s\n", progname, argv[optind]));
        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));
            return 1;
        }
    } else {
        fid = stdin;
    }

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

    /* close input file */
    fclose (fid);
    VERBOSE (DEBUG, fprintf (stderr, "%s: read %d bytes\n", progname, size + n - BUFSIZE));

    /* 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));
            return 1;
        }
    } else {
        fid = stdout;
    }

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

    /* close output file */
    fclose (fid);

    return rc;
}

/* main process */
int process (char *buffer, int nb, FILE *out) {
    int i;

    for (i = 0; (i < nb) && (buffer[i] != 0); i++) {

        VERBOSE (DEBUG, fprintf (stderr, "%s: read '%c' (%u)\n", progname, buffer[i], buffer[i]));
        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)) {
                    mem[p] = buffer[++i];
                } 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 (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;
                    }
                } else {
                    return process (buffer + i + 1, nb - i - 1, out);
                }
                break;
            case ']': /* jump to left bracket if pointer is different to 0 */
                if (mem[p] != 0) {
                    i = -1;
                }
                break;
            case '\n':
            case '\r':
                break;
            default:
                VERBOSE (WARNING, fprintf (stderr, "%s: can't understand '%c'\n", progname, buffer[i]));
        }
        
        //VERBOSE (DEBUG, int _i; fprintf (stderr, "%s: p: %d mem:", progname, p); for (_i = 0; _i < MEMSIZE; _i++) fprintf (stderr, " %d", mem[_i]); fprintf (stderr, "\n"));

    }

    return 0;
}

// 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: echo '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.' | bf.exe
// test: echo '++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++++++++++++++.>+++++++++++++++++.<<++.>+++++++++++++.>--.<<.>+++.+.--.>----.++++++.+.<++.>----.++.<<.>>+.-------.<<.>>++.<.>+++++.<<.>-.+.<.>---.>---.<-.++++++++.>----.<---.>+++++++.<---.++++++++.' | bf.exe
// test: echo ',3>,2>>++++++++++++++++[-<+++<---<--->>>]<<[<[>>+>+<<<-]>>>[<<<+>>>-]<<-]>.' | bf.exe

/* vim: set ts=4 sw=4 et: */