Brainf**k

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
 
#define E_NOINP 1
#define E_MEM 2
#define E_OPEN 3
#define E_READ 4
#define E_PAR 5
#define E_LV 6
#define E_LF 7
#define E_LP 8
#define E_INV 9
#define E_RANGE 10
#define E_UND 11
 
#define MAX_CELLS_CNT 512
#define MAX_LOCAL_FUN_CNT 16
#define MAX_PROGRAM_LENGTH 1024
 
typedef struct fun
{
    size_t ID;
        
    struct fun* localFuns[MAX_LOCAL_FUN_CNT];
    size_t localsCnt;
    
    char pExpr[MAX_PROGRAM_LENGTH];
} fun_t;
 
fun_t* newFun(size_t ID, char* expr, char** pRet);
void delFun(fun_t* pFun);
unsigned char eval(fun_t* pFun);
 
#ifdef DEBUG
void printFun(const fun_t* pFun);
void printLocals(unsigned char* pLocals, size_t size);
#endif
 
void errExit(int code, const char* fmt, ...);
 
int main(int argc, char* argv[])
{
    FILE* pInp;
    char  buf[MAX_PROGRAM_LENGTH + 3];
    fun_t* pTopFun;
    unsigned char result;
    char* p;
    
    p = buf;
    *p = '(';
        
    if(argc != 2)
    errExit(E_NOINP, "Usage: %s FILE\n", *argv);
 
    if((pInp = fopen(argv[1], "r")) == NULL)
    errExit(E_OPEN, "Can't open file `%s' to input.\n", argv[1]);
 
    do
    {
    if(p - buf == MAX_PROGRAM_LENGTH)
        errExit(E_LP, "Maximal program length (%u sybmols) was reached.\n", MAX_PROGRAM_LENGTH);
    
    *(++p) = fgetc(pInp);
    }
    while(!isspace(*p) && (*p != EOF) && (*p != '\0'));
 
    if(ferror(pInp))
    errExit(E_READ, "Error reading from file `%s'.\n", argv[1]);
 
    *p = '\0';
    
    printf("Expression: `%s'.\n\n", buf + 1);
    fflush(stdout);
 
    *p++ = ')';
    *p++ = '\0';
    
#ifdef DEBUG
    fputs("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", stderr);
    fputs("Starting parsing...\n\n", stderr);
#endif
 
    pTopFun = newFun(0, buf, NULL);
 
#ifdef DEBUG
    fputs("Parsing is done.\n", stderr);
    fputs("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", stderr);
    fputc('\n', stderr);
    fputs("Starting evaluation...\n\n", stderr);
#endif
 
    result = eval(pTopFun);
    printf("\nThe result is %u.\n\n", result);
    fflush(stdout);
    
#ifdef DEBUG    
    fputs("Evaluation is done.\n", stderr);
#endif
    delFun(pTopFun);
 
    exit(0);
}
 
fun_t* newFun(size_t ID, char* expr, char** pRet)
{
    fun_t* pFun;
    char* p;
    const char* pExpr;
    
    pExpr = expr;
    
    if((pFun = (fun_t*) malloc(sizeof(fun_t))) == NULL)
    errExit(E_MEM, "Can't allocate memory.\n");
    pFun->ID = ID;
     
    memset(pFun->localFuns, 0, sizeof(fun_t*) * MAX_LOCAL_FUN_CNT);
    pFun->localsCnt = 0;
 
    p = pFun->pExpr;
    ++expr;
    
    while(*expr != ')')
    {
    if(*expr == '(')
    {
        if(pFun->localsCnt == MAX_LOCAL_FUN_CNT)
        errExit(E_LF,
            "Local functions maximum was reached"
            " while parsing expression: `%s'.\n", pExpr);
        
        pFun->localFuns[pFun->localsCnt] = newFun(pFun->localsCnt++, expr, &expr);
    }
    else if(strchr("><+-[],.:", *expr) != NULL)
        *p++ = *expr;
    else if(*expr == '\0')
        errExit(E_PAR, "Mismatched parentheses were detected while parsing expression: `%s'.\n", pExpr);
    else
        errExit(E_INV, "Invalid character: `%c'.\n", *expr);
    
    ++expr;
    }
    
#ifdef DEBUG
    printFun(pFun);
#endif
    
    if(pRet)
    *pRet = expr;
    
    return pFun;
}
 
void delFun(fun_t* pFun)
{
    size_t i;
 
    for(i = 0; i < pFun->localsCnt; ++i)
    {
    delFun(pFun->localFuns[i]);
    pFun->localFuns[i] = NULL;
    }
     
    free(pFun);
    pFun = NULL;
}
 
unsigned char eval(fun_t* pFun)
{
    unsigned char locals[MAX_CELLS_CNT];
    unsigned char* pCurrCell;
    char* pCurrOp;
 
    size_t br = 0;
            
#ifdef DEBUG
    fputs("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", stderr);
    fputs("Entering function...\n", stderr);
    printFun(pFun);
#endif
 
    memset(locals, 0, sizeof(unsigned char) * MAX_CELLS_CNT);
    pCurrCell = locals;
    pCurrOp = pFun->pExpr;
    
    while(*pCurrOp != '\0')
    {
 
#ifdef DEBUG
    fprintf(stderr, "Current operation: `%c'.\n", *pCurrOp);
    fprintf(stderr, "Current cells's (%u) value: %u.\n", pCurrCell - locals,
        (size_t) *pCurrCell);
#endif
    switch(*pCurrOp)
    {
    case '+':
        ++(*pCurrCell);
        break;
        
    case '-':
        --(*pCurrCell);
        break;
 
    case '>':
        if(pCurrCell >= locals + MAX_CELLS_CNT - 1)
        errExit(E_RANGE, "The next cell's index is out of range [0..%u].\n", MAX_CELLS_CNT - 1);
        ++pCurrCell;
        break;
 
    case '<':
        if(pCurrCell <= locals)
        errExit(E_RANGE, "The previous cell's index is out of range [0..%u].\n", MAX_CELLS_CNT - 1);
        --pCurrCell;
        break;
 
    case ',':
        *pCurrCell = getchar();
        break;
 
    case '.':
        putchar(*pCurrCell);
        fflush(stdout);
        break;
 
    case ':':
        if(*pCurrCell >= pFun->localsCnt)
        errExit(E_UND, "Function with local ID #%u is undefinded.\n", *pCurrCell);
        
        *pCurrCell = eval(pFun->localFuns[*pCurrCell]);
        break;
        
    case '[':
        if(*pCurrCell == 0)
        {
        ++pCurrOp;
        if(*pCurrOp == '\0')
            errExit(E_PAR, "Mismatched parentheses were found in function's body: `%s'.\n", pFun->pExpr);
        ++br;
        while(br != 0)
        {
            if(*pCurrOp == '[')
            ++br;
            else if(*pCurrOp == ']')
            --br;
            ++pCurrOp;
            if(*pCurrOp == '\0')
            errExit(E_PAR, "Mismatched parentheses were found in function's body: `%s'.\n", pFun->pExpr);
        }
        --pCurrOp;
        }
        break;
 
    case ']':
        if(*pCurrCell != 0)
        {
        --pCurrOp;
        if(pCurrOp < pFun->pExpr)
            errExit(E_PAR, "Mismatched parentheses were found in function's body: `%s'.\n", pFun->pExpr);
        ++br;
        while(br != 0)
        {
            if(*pCurrOp == '[')
            --br;
            else if(*pCurrOp == ']')
            ++br;
            --pCurrOp;
            if(pCurrOp < pFun->pExpr)
            errExit(E_PAR, "Mismatched parentheses were found in function's body: `%s'.\n", pFun->pExpr);
        }
        }
    }
    ++pCurrOp;
    }
    
#ifdef DEBUG
    printLocals(locals, 10);
    fprintf(stderr, "Return value: %u.\n", (size_t) *pCurrCell);
    fputs("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", stderr);
#endif
    return *pCurrCell;
}
 
#ifdef DEBUG
void printFun(const fun_t* pFun)
{
    fprintf(stderr, "Function with local ID #%u:\n", pFun->ID);
    fprintf(stderr, "Body: `%s'\n", pFun->pExpr);
    fprintf(stderr, "Number of local functions: %u.\n\n", pFun->localsCnt);
}
 
void printLocals(unsigned char* pLocals, size_t size)
{
    size_t i;
    
    fprintf(stderr, "The first %u local cells are:\n", size);
    for(i = 0; i < size; ++i)
    fprintf(stderr, "%u ", (size_t) pLocals[i]);
    fputc('\n', stderr);
}
#endif
 
void errExit(int code, const char* fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    va_end(ap);
    exit(code);
}