My first Brainfuck

I was bored as fuck so I decided to implement a Brainfuck interpreter in C.

/* brainfuck.c ... version 0.9
 *
 * usage: brainfuck <file>
 *
 */

 
#include <stdio.h>

/* 64kb -1b each
 *
 * The Brainfuck spec says that memory should be 30000 bytes, but I prefer to
 * use a whole 64kb for both code and memory.
 *
 */
#define BRAINF_CODESIZE   65535
#define BRAINF_MEMSIZE   65535


FILE* fp;

unsigned char* code, *memory;
short unsigned int codeptr, memptr;


int main(int argc, char* argv[])
{
     if (argc != 2)
          exit(1);

     if ((fp = fopen(argv[1], "r")) == NULL)
          exit(1);

     code = malloc(BRAINF_CODESIZE);
     memory = malloc(BRAINF_MEMSIZE);

     memset(code, 0, BRAINF_CODESIZE);
     memset(memory, 0, BRAINF_MEMSIZE);

     codeptr = 0;
     memptr = 0;

     while (!feof(fp))
     {
          fread(code, BRAINF_CODESIZE -1, 1, fp);
     }


     /*** Interpreting begins ***/
     while (code[codeptr])
     {
          switch (code[codeptr])
          {
               case '>':
                    ++memptr;
                    ++codeptr;
                    break;

               case '<':
                    --memptr;
                    ++codeptr;
                    break;

               case '+':
                    ++memory[memptr];
                    ++codeptr;
                    break;

               case '-':
                    --memory[memptr];
                    ++codeptr;
                    break;

               case '.':
                    putchar(memory[memptr]);
                    ++codeptr;
                    break;

               case ',':
                    memory[memptr] = getchar();
                    ++codeptr;
                    break;

               /* :NOTE: Some kind of error handling should take
                * place if no ']' is found.
                */
               case '[':
                    if (!memory[memptr])
                    {
                         while ((code[codeptr] != ']') && (code[codeptr]))
                         {
                              ++codeptr;
                         }
                    }
                    else
                         ++codeptr;
                    break;


               /* :NOTE: Some kind of error handling should take
                * place if no '[' is found.
                */
               case ']':
                    if (memory[memptr])
                    {
                         while ((code[codeptr] != '[') && (codeptr))
                              --codeptr;
                    }
                    else
                         ++codeptr;
                    break;

               /* invalid instruction
                * For now we will just continue executing when this happens.
                * It should ignore characters 10, 13, & 32 anyways.
                */
               default:
                    ++codeptr;
                    break;
          }
     }

     free(code);
}

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

int main(int argc, char **argv)
{
    if (!(argc == 2 || argc == 3))
    {
    fprintf(stderr, "Usage: ./brainfuck source [memory]\n");
    exit(1);
    }

    FILE *inFP;

    if ((inFP = fopen(argv[1], "r")) == NULL)
    {
    fprintf(stderr, "Cannot open source file\n");
    exit(1);
    }

    char *sigma = "+-<>.,[]";
    int lb = 0, rb = 0, count = 0, i;
    char temp;

    while ((temp = fgetc(inFP)) != EOF)
    {
    for (i = 0; i < strlen(sigma); i++)
        if (sigma[i] == temp)
        count++;
    if (temp == '[')
        lb++;
    if (temp == ']')
    {
        rb++;
        if (lb - rb < 0)
        {
        fprintf(stderr, "Syntax error: bracket underflow\n");
        exit(1);
        }
    }
    }
    if (lb - rb > 0)
    {
    fprintf(stderr, "Syntax error: bracket overflow\n");
    exit(1);
    }

    rewind(inFP);

    char *source = (char *)malloc(sizeof(char) * count);
    int pos = 0;
    while ((temp = fgetc(inFP)) != EOF)
    for (i = 0; i < strlen(sigma); i++)
        if (sigma[i] == temp)
        source[pos++] = temp;

    int msize = 30000;
    if (argc == 3)
    msize = atoi(argv[2]);
    char *memory = (char *)malloc(sizeof(int) * msize);
    for (i = 0; i < msize; i++)
    memory[i] = 0;
    char *mptr = memory;
    char *sptr = source;
    char **stack = (char **)malloc(sizeof(char *) * lb);
    int stack_size = 0;
    while (sptr < source + count)
    {
    temp = *sptr;
    if (temp == '+') (*mptr)++;
    if (temp == '-') (*mptr)--;
    if (temp == '>') mptr++;
    if (temp == '<') mptr--;
    if (temp == ',') *mptr = fgetc(stdin);
    if (temp == '.') fputc(*mptr, stdout);
    if (temp == '[')
    {
        if (*mptr > 0)
        stack[stack_size++] = sptr;
        else
        while (*sptr != ']')
            sptr++;
    }
    if (temp == ']')
    {
        if (*mptr > 0)
        sptr = stack[stack_size-1];
        else
        --stack_size;
    }
    sptr++;
    }
   
    free(stack);
    free(memory);
    free(source);
}