file = IO::readlines(ARGV[0].join.gsub(/[^\+\-\<\>\[\]\.\,]/, "")
ARGV.clear
reader, ptr, data, ret_stack, skipping = 0, 0, [0], [], nil

until reader == file.size
	unless skipping
		case file[reader]
			when ">" then ptr += 1; data.concat([0] if ptr == data.size
			when "<" then ptr -= 1 unless ptr.zero?
			when "+" then data[ptr] = (data[ptr].nil? ? 0 : data[ptr] + 1
			when "-" then data[ptr] = (data[ptr].nil? ? 0 : data[ptr] - 1
			when "[" then eval(data[ptr].zero? ? "skipping = ret_stack.size + 1" : "skipping = nil"); ret_stack.push(reader)
			when "]" then eval(data[ptr].zero? ? "ret_stack.pop" : "reader = ret_stack.last")
			when "." then print(data[ptr].chr)
			when "," then data[ptr] = gets.getbyte(0)
		end
	else
		case file[reader]
			when "[" then ret_stack.push(reader)
			when "]" then ret_stack.pop
		end
		skipping = nil if skipping > ret_stack.size
	end
	reader += 1
end

import sys

class _Getch: # A cross-platform method to read a single character, obtained from activestate.com
    def __init__(self):
        try:
            self.impl = _GetchWindows()
        except ImportError:
            self.impl = _GetchUnix()
    def __call__(self): return self.impl()

class _GetchUnix:
    def __init__(self):
        import tty, sys
    def __call__(self):
        import tty, sys, termios
        fd = sys.stdin.fileno()
        old_settings = termios.tcgetattr(fd)
        try:
            tty.setraw(sys.stdin.fileno())
            ch = sys.stdin.read(1)
        finally:
            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
        return ch

class _GetchWindows:
    def __init__(self):
        import msvcrt

    def __call__(self):
        import msvcrt
        return msvcrt.getch()

getch = _Getch()


if len(sys.argv) != 2: # If they didn't supply a file to parse...
    file = sys.stdin #...parse standard input.
else:
    file = open(sys.argv[1], "r")

stack = []
data = [0]
ptr = 0
skip = 0

while True:
    cur = file.read(1)
    if not cur: break # We hit the end of the file.
    elif not skip:
        if cur == ">":
            ptr += 1
            if ptr >= len(data):
                data.append(0)
        elif cur == "<":
            if ptr > 0: ptr -= 1
            else:
                data.insert(0, 0)
        elif cur == "+":
            data[ptr] += 1
        elif cur == "-":
            data[ptr] -= 1
        elif cur == ".":
            print(chr(data[ptr], end="") # Don't add a newline after printing.
        elif cur == ",":
            data[ptr] = ord(getch())
        elif cur == "[":
            stack.append(file.tell())
            if data[ptr] == 0: skip = len(stack)
        elif cur == "]":
            if data[ptr] == 0: stack.pop()
            else: file.seek(stack[-1]
    else:
        if cur == "[":
            stack.append(file.tell())
        elif cur == "]":
            stack.pop()
        if skip > len(stack): skip = 0

+++++ +++++             initialize counter (cell #0) to 10
[                       use loop to set the next four cells to 70/100/30/10
    > +++++ ++              add  7 to cell #1
    > +++++ +++++           add 10 to cell #2 
    > +++                   add  3 to cell #3
    > +                     add  1 to cell #4
    <<<< -                  decrement counter (cell #0)
]                   
> ++ .                  print 'H'
> + .                   print 'e'
+++++ ++ .              print 'l'
.                       print 'l'
+++ .                   print 'o'
> ++ .                  print ' '
<< +++++ +++++ +++++ .  print 'W'
> .                     print 'o'
+++ .                   print 'r'
----- - .               print 'l'
----- --- .             print 'd'
> + .                   print '!'
> .                     print '\n'

,
[
	>
	+++++ +++++             initialize counter (cell #1) to 10
	[                       use loop to set the next four cells to 70/100/30/10
		> +++++ ++              add  7 to cell #2
		> +++++ +++++           add 10 to cell #3 
		> +++                   add  3 to cell #4
		> +                     add  1 to cell #5
		<<<< -                  decrement counter (cell #1)
	]                   
	> ++ .                  print 'H'
	> + .                   print 'e'
	+++++ ++ .              print 'l'
	.                       print 'l'
	+++ .                   print 'o'
	> ++ .                  print ' '
	<< +++++ +++++ +++++ .  print 'W'
	> .                     print 'o'
	+++ .                   print 'r'
	----- - .               print 'l'
	----- --- .             print 'd'
	> + .                   print '!'
	> .                     print '\n'
	[[-]<]						clear all previous cells stopping at cell #1 (which is empty)
	< -
]

K:\Games\Python Tomfoolery>BF_int.py bf_prog_2.txt
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!

K:\Games\Python Tomfoolery>

#include <iostream>
#include <deque>
#include <stack>
#include <iterator>
#include <fstream>

class Brainfuck
{
    private:
        typedef std::basic_istream<char>& inputStream;
        typedef std::basic_ostream<char>& outputStream;

        inputStream commandStream; //The command input stream
        std::istream_iterator<char> it; //Input iterator.

        //Brainfuck-specific streams
        outputStream dataOutput; //Stream to dump output to (such as std::cout)
        inputStream dataInput; //Stream to receive user input from (such as std::cin)

        //Deque provides efficient insertion/deletion of elements at both ends but does not allocate memory in a singular
        //contiguous chunk like a vector, hence standard pointer arithmetic cannot be used.
        //Was getting some seg faults when running the 'beer.b' program; switching to unsigned char
        //solved this and also prevented data from dropping below 0.
        std::deque<unsigned char> data;
        std::deque<unsigned char>::iterator dataIterator;

        std::stack<std::streampos> jumpStack;
    public:
        Brainfuck(inputStream cmdStream, outputStream dataOutStream, inputStream dataInStream)
                : commandStream(cmdStream), it(cmdStream), dataOutput(dataOutStream), dataInput(dataInStream)
        {
                    dataIterator = data.begin();
        }

        void operator() ()
        {
            int skipDepth = 0;
            std::istream_iterator<char> end; //Default ctor creates an 'invalid' iterator.

            for (; it != end; ++it)
            {
                if (skipDepth != 0)
                {
                    if (*it == '[')
                    {
                        jumpStack.push(commandStream.tellg());
                    }
                    else if (*it == ']')
                    {
                        jumpStack.pop();
                    }

                    if (jumpStack.size() < skipDepth) //Last bracket set found...
                    {
                        skipDepth=0;
                    }
                    continue;
                }
                
                switch (*it)
                {
                    case '+':
                        ++(*dataIterator);
                        break;
                    case '-':
                        --(*dataIterator);
                        break;
                    case '>':
                        if (++dataIterator == data.end()) //Reached the end of the deque
                        {
                            data.push_back(0);
                        }
                        break;
                    case '<':
                        if (--dataIterator == data.end())
                        {
                            data.push_front(0);
                        }
                        break;
                    case '.':
                        dataOutput<<*dataIterator;
                        break;
                    case ',':
                         *dataIterator = dataInput.get(); //Technically this could overflow; get() is casted to an int first but unless
                                                                       //your native language is mandorin I doubt it'll be a problem.
                        //synchronise the rdbuf; this is incase you tried to be clever and entered more than one byte into the stream,
                        //syncing will discard all unread characters.
                        dataInput.sync();
                        break;
                    case '[':
                        jumpStack.push(commandStream.tellg());
                        if (*dataIterator == 0)
                        {
                            skipDepth = jumpStack.size();
                        }
                        break;
                    case ']':
                        if (*dataIterator == 0)
                        {
                            jumpStack.pop();
                        }
                        else
                        {
                            commandStream.seekg(jumpStack.top());
                        }
                        break;
                }
            } 
        }

};

int main(int argc, char** argv)
{
    if (argc != 2)
    {
        std::cout<<"USAGE: brainfuck <file>\nNo file specified";
        return -1;
    }
    std::ifstream file(argv[1];

    if ( !file.good())
    {
        std::cout<<"USAGE: brainfuck <file>\nBad file name";
        return -1;
    }

    //Using streams like this means you can redirect output or input to another file or another user over the network etc.
    Brainfuck bf(file, std::cout, std::cin);
    bf();

    return 0;
}