uBF interpreter

//uBF.c - an interpreter for the BrainF~ programming language
 
#include <stdio.h>
#include <stdlib.h>
 
//Windows-specific code
#include <conio.h>
#define GET_CHAR _getch
//End
 
#define BUFFERING_SIZE 2048
 
int main(int argc, char **argv)
{
	puts("uBF interpreter, by Ultraminor");
 
	if(argc<2)
	{
		puts("Usage: ubf <source file>");
		return 0;
	}
 
	FILE *inputFile=fopen(argv[1],"rb");
	if(!inputFile)
	{
		puts("Unable to open source file for reading");
		return 1;
	}
 
	unsigned char *memory=malloc(sizeof(unsigned char)*BUFFERING_SIZE);
	if(!memory)
	{
		puts("Unable to allocate memory");
		return 1;
	}
 
	unsigned char *source;
	long sourceSize;
 
	if(
		fseek(inputFile, 0, SEEK_END)||
		(sourceSize=ftell(inputFile))==-1||
		!(source=malloc(sizeof(unsigned char)*sourceSize))||
		fseek(inputFile, 0, SEEK_SET)||
		fread(source, 1, sourceSize, inputFile)!=sourceSize
	)
	{
		puts("Unable to load source from input file");
		return 1;
	}
 
	fclose(inputFile);
 
	unsigned int memoryPointer=0, memorySize=BUFFERING_SIZE, instructionPointer,i;
 
	int charBuffer;
 
	for(i=0;i<BUFFERING_SIZE;i++)
	{
		memory[i]=0;
	}
 
	for(instructionPointer=0;instructionPointer<sourceSize;instructionPointer++)
	{
		switch(source[instructionPointer])
		{
			case '+':
				memory[memoryPointer]++;
				break;
 
			case '-':
				memory[memoryPointer]--;
				break;
 
			case '>':
				memoryPointer++;
				if(memoryPointer==memorySize)
				{
					memorySize+=BUFFERING_SIZE;
					memory=realloc(memory, sizeof(unsigned char)*memorySize);
					if(!memory)
					{
						puts("Unable to allocate memory");
						return 1;
					}
 
					for(i=memoryPointer;i<memorySize;i++)
					{
						memory[i]=0;
					}
				}
				break;
 
			case '<':
				if(memoryPointer>0)
				{
					memoryPointer--;
				}
				break;
 
			case '.':
				putchar(memory[memoryPointer]);
				break;
 
			case ',':
				charBuffer=GET_CHAR();
				if(charBuffer!=EOF)
				{
					memory[memoryPointer]=charBuffer;
				}
				break;
 
			case '[':
				if(!memory[memoryPointer])
				{
					i=1;
					while(i>0&&instructionPointer<sourceSize)
					{
						instructionPointer++;
						if(source[instructionPointer]==']')
						{
							i--;
						}
						else if(source[instructionPointer]=='[')
						{
							i++;
						}
					}
				}
				break;
			case ']':
				if(memory[memoryPointer])
				{
					i=1;
					while(i>0&&instructionPointer>0)
					{
						instructionPointer--;
						if(source[instructionPointer]==']')
						{
							i++;
						}
						else if(source[instructionPointer]=='[')
						{
							i--;
						}
					}
				}
		}
	}
 
	return 0;
}