[HaBo]

import sys

CS = ""
DS = dict()
DP = 0
IP = 0
JS = list()

if sys.argv[1] == "-c":
	CS = sys.argv[2]
else:
	CS = str().join(open(sys.argv[1],'r').readlines())

while IP <= len(CS) - 1:
	if CS[IP] == "<":
		DP = DP - 1
        elif CS[IP] == ">":
		DP = DP + 1
	elif CS[IP] == "-":
		if not DS.has_key(DP):
			DS[DP] = 0
		DS[DP] = (DS[DP] - 1)  % 256
	elif CS[IP] == "+":
		if not DS.has_key(DP):
			DS[DP] = 0
		DS[DP] = (DS[DP] + 1) % 256
	elif CS[IP] == ".":
		if not DS.has_key(DP):
			DS[DP] = 0
		sys.stdout.write(chr(DS[DP]))
	elif CS[IP] == ",":
		DS[DP] = ord(sys.stdin.read(1))
	elif CS[IP] == '[':
		if not DS.has_key(DP):
			DS[DP] = 0
		if DS[DP] != 0:
			JS.append(IP)
		else:
			Token = 1
			IP = IP + 1
			while Token > 0:
				if CS[IP] == '[':
					Token = Token + 1
				elif CS[IP] == ']':
					Token = Token - 1
				IP = IP + 1
			IP = IP - 1
	elif CS[IP] == "]":
		IP = JS.pop() - 1
	IP = IP + 1

#!/usr/bin/env perl
use strict;

BEGIN {undef $/}

my $bf_src = <>;

my %transHash = (
                    ">" => "++ptr;",
                    "<" => "--ptr;",
                    "+" => "++*ptr;",
                    "-" => "--*ptr;",
                    "." => "putchar(*ptr);",
                    "," => "*ptr = getchar();",
                    "[" => "while (*ptr) {",
                    "]" => "}"
                );

print "#include <stdio.h>\n";
print "#include <stdlib.h>\n";
print "int main(void) {\n";

my $incr_c = () = $bf_src =~ />/g;
$incr_c++;
print "int *ptr = malloc($incr_c * sizeof(int));\n";

foreach (split(//, $bf_src)) {
    print "$transHash{$_} ";
}

print "return 0;}\n";

#include <iostream>
#include <fstream>
#define FIELD_SIZE 1024
using namespace std;

int findClosingBracket(string &bfCode, int pos)
{
    unsigned curDepth = 0;
    for (unsigned i = 1; i < bfCode.length() - pos; i++) {
        switch (bfCode[pos + i]) {
            case '[':
                ++curDepth;
                break;
            case ']':
                if (curDepth == 0) return i;
                --curDepth;
                break;
        }
    }
    return -1;
}

void bfParser(char *field, int fieldPos, string &bfCode)
{
    int posClosingBracket;

    for (unsigned codePos = 0; codePos < bfCode.length(); codePos++) {
        switch (bfCode[codePos]) {
            case '+':
                ++field[fieldPos];
                break;
            case '-':
                --field[fieldPos];
                break;
            case '>':
                ++fieldPos;
                break;
            case '<':
                --fieldPos;
                break;
            case '.':
                cout << field[fieldPos];
                break;
            case ',':
                cin >> field[fieldPos];
                break;
            case '[':
                posClosingBracket = findClosingBracket(bfCode, codePos);
                if (field[fieldPos] > 0) {
                    string newCode = bfCode.substr(codePos+1, posClosingBracket - 1);
                    bfParser(field, fieldPos, newCode);
                    --codePos; // hier bleiben!
                } else {
                    codePos += posClosingBracket;
                }
                break;
            case ']':
                break;
        }
        if (fieldPos < 0 || fieldPos >= FIELD_SIZE) {
            cerr << "Index out of Range: " << fieldPos << endl;
            return;
        }
    }
}
    

int main(int argc, char **argv)
{
    if (argc != 2) {
        cerr << "Usage: %s <file>\n" << argv[0] << endl;
        return 1;
    }
    
    char *field = new char[FIELD_SIZE];
    
    ifstream codeFile(argv[1]);
    if (!codeFile.is_open()) {
        cerr << "Konnte Datei nicht oeffnen!" << endl;
        return 1;
    }

    string bfCode;
    while (!codeFile.eof()) {
        string line;
        getline(codeFile, line);
        bfCode += line;
    }
    
    bfParser(field, 0, bfCode);
}

.186
CSEG segment
org 100h

Begin:
    mov    dx, offset Filename    
    mov    ah,3dh  ;al sollte per default 0 sein
    int    21h
    xchg bx,ax ;braucht nur 1 byte
    ;Speicher vorbereiten, jeweils 65k für BF Code und BF Array reservieren und Nullen
    mov cx,cs
    add cx,0ffffh/15 ;bisschen Platz für eigentlichen Com-code lassen
    mov es,cx
    xor cx,cx ;auf Anzahl der Bytes bringen
    dec cx 
    ;zeromemory , ax ist durch xchg bx,ax=0
    rep stosb
    
    
    ;File lesen     
    xchg cx,di ;mov cx, di
           ;       inc di ; di auf 0
    mov    ah,3fh 
    int    21h
    mov    si,dx  ;nötig???
    add    dx,ax
     
    ;schließen (später löschen!)
    mov    ah,3eh
    int    21h
    mov    bx,dx
    ;Nun SI ist der Zeiger auf Code
    ;DI zeiger auf Array
    INTERPRET:
       cld
       lodsb
       cmp al,'<'
       jne @f
          dec DI
       @@:
       cmp al,'>'
       jne @f
          inc DI
       @@:
       cmp al,'+'
       jne @f
          inc byte ptr es:[DI]
       @@:
       cmp al,'-'
       jne @f
          dec byte ptr es:[DI]
       @@:
       cmp al,'.'
       jne @f
          mov ah,02
          mov dl,byte ptr es:[DI]
          int 21h
       @@:
       cmp al,','
       jne @f
          mov ah,01          
          int 21h
          mov byte ptr es:[DI],al
          xchg cx,ax ;jmp ENDE CX ist i.R 0, also wird weitere ausführung nicht beeinflüsst
       @@:
       
       ;[ 	jump forward to the command after the corresponding ] if the byte at the pointer is zero.
       ;] 	jump back to the command after the corresponding [ if the byte at the pointer is nonzero.
       xor cx,cx
       cmp byte ptr es:[DI],cl         
       jnz NEXT_BRC ;es ist nicht 0 , also interessiert [ Scan uns gar nicht, sonst:
       
       cmp al,'['    ;ansonten ist [ und Zelle 0       
       je INC_   
       ; oder nicht [ und 0, dann interessirt und auch der ] Fall nicht 
       jmp ENDE  
          
       NEXT_BRC:        
       cmp al,']';hier=>Zelle nicht 0 -> scannen nach [
       jne ENDE
          std 
          dec si 
               
          SCAN_LOOP:
             lodsb             
             cmp al,'['
             je INC_
             cmp al,']'
             jne SCAN_LOOP   ;sonst ist es ] ->dec          
             dec cx
             jz ENDE
             jmp SCAN_LOOP
           INC_:   inc cx
             jnz SCAN_LOOP  ;wenn ungleich, kann weitergescannt werden
             
         inc si    ;korrigiere SI  
         inc si
                          
              
    ENDE:
    cmp SI,bx
    jbe INTERPRET   
    
    int 20h    
filename db 'i',0   

CSEG ends
end Begin

package Brainfuck;
use strict;

sub new {
    my $class = shift;
    my %opts  = @_;
    my $self  = {
        stdin   => exists $opts{stdin}   ? $opts{stdin}   : *STDIN,
        stdout  => exists $opts{stdout}  ? $opts{stdout}  : *STDOUT,
        timeout => exists $opts{timeout} ? $opts{timeout} : 10,
        ptr     => [],
        idx     => 0,
    };
    bless $self, $class;
    return $self;
}

sub eval {
    my ($self, $expr) = @_;
    eval {
        local $SIG{ALRM} = sub { die; };
        alarm $self->{timeout};
        $self->_eval($expr);
    };
    alarm 0;
    return;
}

sub reset {
    my ($self) = @_;
    $self->{ptr} = [];
    $self->{idx} = 0;
    return;
}

sub _eval {
    my ($self, $expr) = @_;
    my @whileStack;
    my $openCount = 0;         # open bracket count.

    for my $char ($expr =~ /([\[\]\-+.,<>])/g) {
      SWITCH: {
            if (@whileStack && $char ne ']' && $char ne '[') {
                push @whileStack, $char;
                last SWITCH;
            }
            if ($char eq '>') { $self->{idx}++;               last SWITCH; }
            if ($char eq '<') { $self->{idx}--;               last SWITCH; }
            if ($char eq '+') { $self->{ptr}[$self->{idx}]++; last SWITCH; }
            if ($char eq '-') {
                if ($self->{ptr}[$self->{idx}]) {
                    $self->{ptr}[$self->{idx}]--;
                    last SWITCH; 
                }
            }
            if ($char eq ',') {
                if (ref(\$self->{stdin}) eq 'GLOB') {
                    $self->{ptr}[$self->{idx}] = ord(getc $self->{stdin});
                }
                elsif (ref($self->{stdin}) eq 'SCALAR') {
                    $char = substr ${$self->{stdin}}, 0, 1, '';
                    # get the first char out of the stdin variable.
                    $self->{ptr}[$self->{idx}] = ord $char;
                }
                else {
                    my $randchar
                      = int(rand(95)) + 33;    # we only want printable chars.
                    $self->{ptr}[$self->{idx}] = $randchar;
                }
                last SWITCH;
            }
            if ($char eq '.' && $self->{stdout}) {
                if (ref(\$self->{stdout}) eq 'GLOB') {
                    print {$self->{stdout}} chr $self->{ptr}[$self->{idx}];
                }
                elsif (ref($self->{stdout}) eq 'SCALAR') {
                    ${$self->{stdout}} .= chr $self->{ptr}[$self->{idx}];
                }
                last SWITCH;
            }

            if ($char eq '[') {
                push @whileStack, $char;
                $openCount++;
                last SWITCH;
            }
            if ($char eq ']' && $openCount > 1) {
                push @whileStack, $char;
                $openCount--;
                last SWITCH;
            }
            if (   $char eq ']'
                && @whileStack
                && $openCount == 1)
            {
                shift @whileStack;  # get rid of the first opening bracket.
                my $code = '';
                while (my $char = shift @whileStack) {
                    $code .= $char;
                }
                while ($self->{ptr}[$self->{idx}]) {
                    $self->_eval($code);
                }
                $openCount = 0;
                last SWITCH;
            }
        }
    }
    return;
}

1;

#!/usr/bin/env perl
use warnings;
use strict;
use Term::ReadLine;

print "Interactive brainfuck. Commands that take longer than\n";
print "3 seconds will time out. h for help, q for quit.\n";

my $out     = '';
my $bf      = Brainfuck->new(stdout => \$out, stdin => 0, timeout => 3);
my $term    = Term::ReadLine->new('brainfucker');
my $prompt  = '{bf::in  } ';
my $verbose = 0;
my @stored;
my @genericStored;

while (defined(my $line = $term->readline($prompt))) {
    $bf->eval($line);
    if ($out) {
        print "{bf::out } $out\n";
        $out = '';
    }
    $line =~ /^(?:q(?:uit)?|e(?:xit)?)/ and exit;
    $line =~ /^p(?:rint)?$/             and dumpInfo($bf);
    $line =~ /^s(?:tore)?$/             and store($bf, \@genericStored);
    $line =~ /^s(?:tore)?\s+(\d+)$/     and store($bf, \@stored, $1);
    $line =~ /^r(?:estore)?$/           and restore($bf, \@genericStored);
    $line =~ /^r(?:estore)?\s+(\d+)$/   and restore($bf, \@stored, $1);
    $line =~ /^c(?:lear)?$/             and $bf->reset();
    $line =~ /^h(?:elp)?$/              and help();
    $line =~ /\S/                       and $term->addhistory($line);
}

sub restore {
    my ($bf, $stored, $n) = @_;
    if (defined $n) {
        ($bf->{idx}, $bf->{ptr})
          = ($stored->[$n][0], [@{ $stored->[$n][1] }]);
    }
    else {
        ($bf->{idx}, $bf->{ptr})
          = ($stored->[0], [@{ $stored->[1] }]);
    }
    return;
}

sub store {
    my ($bf, $stored, $n) = @_;
    if (defined $n) {
        $stored->[$n] = [$bf->{idx}, [@{ $bf->{ptr} }]];
    }
    else {
        @$stored = ($bf->{idx}, [@{ $bf->{ptr} }]);
    }
    return;
}

sub dumpInfo {
    my ($bf) = @_;
    my $ptr  = '[';
    my $i    = 0;
    my @tmpPtr = map { $_ || 0 } @{$bf->{ptr}};
    for (0 .. ($bf->{idx} - @tmpPtr)) {
        push @tmpPtr, 0;
    }
    for my $n (@tmpPtr) {
        $ptr .=
          ($i == $bf->{idx})
          ? sprintf "(%d), ", $n
          : sprintf "%d, ", $n;
        $i++;
    }
    $ptr =~ s/, $/]/;
    print "{bf::ptr }$ptr\n";
    return;
}

sub help {
    print "(cmd)------->(meaning)\n\n";
    print "(clear)----->(reset ptr)\n";;
    print "(store)----->(store ptr)\n";
    print "(restore)--->(restore ptr)\n";
    print "(store n)--->(store as ptr n)\n";
    print "(restore n)->(restore ptr n)\n";
    print "(print)----->(dump ptr)\n";
    print "(help)------>(show help)\n";
    print "(quit)------>(exit)\n";
    print "(exit)------>(exit)\n\n";
    return;
}


package Brainfuck;
use strict;

sub new {
    my $class = shift;
    my %opts  = @_;
    my $self  = {
        stdin   => exists $opts{stdin}   ? $opts{stdin}   : *STDIN,
        stdout  => exists $opts{stdout}  ? $opts{stdout}  : *STDOUT,
        timeout => exists $opts{timeout} ? $opts{timeout} : 10,
        ptr     => [],
        idx     => 0,
    };
    bless $self, $class;
    return $self;
}

sub eval {
    my ($self, $expr) = @_;
    eval {
        local $SIG{ALRM} = sub { die; };
        alarm $self->{timeout};
        $self->_eval($expr);
    };
    alarm 0;
    return;
}

sub reset {
    my ($self) = @_;
    $self->{ptr} = [];
    $self->{idx} = 0;
    return;
}

sub _eval {
    my ($self, $expr) = @_;
    my @whileStack;
    my $openCount = 0;         # open bracket count.

    for my $char ($expr =~ /([\[\]\-+.,<>])/g) {
      SWITCH: {
            if (@whileStack && $char ne ']' && $char ne '[') {
                push @whileStack, $char;
                last SWITCH;
            }
            if ($char eq '>') { $self->{idx}++;               last SWITCH; }
            if ($char eq '<') { $self->{idx}--;               last SWITCH; }
            if ($char eq '+') { $self->{ptr}[$self->{idx}]++; last SWITCH; }
            if ($char eq '-') {
                if ($self->{ptr}[$self->{idx}]) {
                    $self->{ptr}[$self->{idx}]--;
                    last SWITCH; 
                }
            }
            if ($char eq ',') {
                if (ref(\$self->{stdin}) eq 'GLOB') {
                    $self->{ptr}[$self->{idx}] = ord(getc $self->{stdin});
                }
                elsif (ref($self->{stdin}) eq 'SCALAR') {
                    $char = substr ${$self->{stdin}}, 0, 1, '';
                    # get the first char out of the stdin variable.
                    $self->{ptr}[$self->{idx}] = ord $char;
                }
                else {
                    my $randchar
                      = int(rand(95)) + 33;    # we only want printable chars.
                    $self->{ptr}[$self->{idx}] = $randchar;
                }
                last SWITCH;
            }
            if ($char eq '.' && $self->{stdout}) {
                if (ref(\$self->{stdout}) eq 'GLOB') {
                    print {$self->{stdout}} chr $self->{ptr}[$self->{idx}];
                }
                elsif (ref($self->{stdout}) eq 'SCALAR') {
                    ${$self->{stdout}} .= chr $self->{ptr}[$self->{idx}];
                }
                last SWITCH;
            }

            if ($char eq '[') {
                push @whileStack, $char;
                $openCount++;
                last SWITCH;
            }
            if ($char eq ']' && $openCount > 1) {
                push @whileStack, $char;
                $openCount--;
                last SWITCH;
            }
            if (   $char eq ']'
                && @whileStack
                && $openCount == 1)
            {
                shift @whileStack;  # get rid of the first opening bracket.
                my $code = '';
                while (my $char = shift @whileStack) {
                    $code .= $char;
                }
                while ($self->{ptr}[$self->{idx}]) {
                    $self->_eval($code);
                }
                $openCount = 0;
                last SWITCH;
            }
        }
    }
    return;
}

1;

#include <iostream>
#include <fstream>
#include <string>

//some datatype definition
//todo: make it dynamic for "infinit" size -> array
#define CellType unsigned int
unsigned int CellSize=30000;

//Define brainfuck operators
enum
{
    OP_NEXT=0,
    OP_PREV,
    OP_PLUS,
    OP_MINUS,
    OP_OUT,
    OP_INP,
    OP_JUMP_IN,
    OP_JUMP_OUT
};

char operators[] = {'>','<',
                    '+','-',
                    '.',',',
                    '[',']'};
//is the character an operator?
bool isOP(char op);
//extract sourcecode from a file
bool extractSource(char *filename, char *source);
//interpret brainfuck sourcecode
bool interpret(std::string source, CellType *cells);
//extract loop out of source.
//ip = instruction pointer = current position in code
//posBracket = returns the value of close loop bracket
//return value: string with loopsource
//                "-1" if error
std::string extractLoop(std::string source, int ip, int &posBracket);


int main(int argc, char *argv[])
{
    //test wether the filename is given
    if(argc<2)
    {
        std::cout<<"usage: brainfuck filename\n";
        return -1;
    }

    //contains sourcecode
    char *source;
    //get the source from the filename
    extractSource(argv[1], source);

    //free the buffer
    if(source)
    {
        delete[] source;
        source = NULL;
    }

    return 0;
}

//is operator?
bool isOP(char op)
{
    //go through all operators
    for(int i=0; i<sizeof(operators)/sizeof(char); i++)
    {
        if(op==operators[i])
            return true;
    }

    return false;
}

//extract sourcecode from filename
bool extractSource(char *filename, char *source)
{
    //get the filesize
    std::ifstream input(filename);
    if(!input)
        return false;

    input.seekg(0, std::ios::end);
    unsigned int fileSize = input.tellg();

    //create source buffer
    source = new char[fileSize+1];

    //reset file stream to the beginning of the file
    input.clear();
    input.seekg(0, std::ios::beg);

    if(input.is_open())
    {
        //get the source, cancel all comments and other characters
        int index=0;
        while(!input.eof() && index<=fileSize)
        {
           input.get(source[index]);
           if(isOP(source[index]))
            index++;
        }
        source[index]='\0';

        input.close();
    }

    //create our cells
    CellType *cell;
    cell = new CellType[CellSize];
    memset(cell, 0, CellSize);

    //interpret brainfuck
    interpret(source, cell);
    if(cell)
    {
        delete[] cell;
        cell = NULL;
    }

    return true;
}

//extract loop from sourcecode
std::string extractLoop(std::string source, int ip, int &posBracket)
{
    //save the position of closing bracket
    int posClose=-1;
    //size of interlaced loops
    int numOpen=1;
    //go through the code end extract the whole loop
    for(int index = ip+1; index<source.size(); ++index)
    {
        //found closing bracket
        if(source[index]==operators[OP_JUMP_OUT])
        {
            //decrease interlaced depth
            --numOpen;
            //save if we have the outermost loop
            if(numOpen==0)
            {
                posClose=index;
                break;
            }
        }
        //found begining of another loop
        else if(source[index]==operators[OP_JUMP_IN])
        {
            //increase the depth
            ++numOpen;
        }
    }

    if(numOpen)
    {
        std::cout<<"Error: Loop is not closed!"<<std::endl;
        return "-1";
    }

    //save our closing bracket position
    posBracket = posClose;

    //extract the loop and save it
    int codeSize = posClose-ip-1;
    std::string loop;
    return source.substr(ip+1, codeSize);
}//end extractLoop

//interpret brainfuck source
bool interpret(std::string source, CellType *cell)
{
    //position in the cell
    static CellType dataPointer = 0;

    //go through the loop and interpret
    for(int ip=0; ip<source.size(); ++ip)
    {
        //create more buffer, if not sufficient
       if(ip>=CellSize)
       {
           CellSize *= 2;
           realloc(cell, CellSize);
       }

       if(source[ip]==operators[OP_NEXT])
       {
            ++dataPointer;
       }
       else if(source[ip]==operators[OP_PREV])
       {
            --dataPointer;
       }
       else if(source[ip]==operators[OP_PLUS])
       {
            ++cell[dataPointer];
       }
       else if(source[ip]==operators[OP_MINUS])
       {
           if(cell[dataPointer])
                --cell[dataPointer];

       }
       else if(source[ip]==operators[OP_OUT])
       {
            std::cout<<static_cast<char>(cell[dataPointer]);
       }
       else if(source[ip]==operators[OP_INP])
       {
            std::cin>>cell[dataPointer];
       }
       else if(source[ip]==operators[OP_JUMP_IN])
       {
            std::string loop;
            int posClose;
            loop = extractLoop(source, ip, posClose);

            if(loop == "-1")
                return false;

            while(cell[dataPointer])
            {
                interpret(loop, cell);
            }

            ip=posClose;
       }
    }

    return true;
}//end interpret

99 Bottles of Beer in Urban Mueller's BrainF*** (The actual
name is impolite)

by Ben Olmstead

ANSI C interpreter available on the internet; due to
constraints in comments the address below needs to have the
stuff in parenthesis replaced with the appropriate symbol:

http://www(dot)cats(dash)eye(dot)com/cet/soft/lang/bf/

Believe it or not this language is indeed Turing complete!
Combines the speed of BASIC with the ease of INTERCAL and
the readability of an IOCCC entry!

>+++++++++[<+++++++++++>-]<[>[-]>[-]<<[>+>+<<-]>>[<<+>>-]>>>
[-]<<<+++++++++<[>>>+<<[>+>[-]<<-]>[<+>-]>[<<++++++++++>>>+<
-]<<-<-]+++++++++>[<->-]>>+>[<[-]<<+>>>-]>[-]+<<[>+>-<<-]<<<
[>>+>+<<<-]>>>[<<<+>>>-]>[<+>-]<<-[>[-]<[-]]>>+<[>[-]<-]<+++
+++++[<++++++<++++++>>-]>>>[>+>+<<-]>>[<<+>>-]<[<<<<<.>>>>>-
]<<<<<<.>>[-]>[-]++++[<++++++++>-]<.>++++[<++++++++>-]<++.>+
++++[<+++++++++>-]<.><+++++..--------.-------.>>[>>+>+<<<-]>
>>[<<<+>>>-]<[<<<<++++++++++++++.>>>>-]<<<<[-]>++++[<+++++++
+>-]<.>+++++++++[<+++++++++>-]<--.---------.>+++++++[<------
---->-]<.>++++++[<+++++++++++>-]<.+++..+++++++++++++.>++++++
++[<---------->-]<--.>+++++++++[<+++++++++>-]<--.-.>++++++++
[<---------->-]<++.>++++++++[<++++++++++>-]<++++.-----------
-.---.>+++++++[<---------->-]<+.>++++++++[<+++++++++++>-]<-.
>++[<----------->-]<.+++++++++++..>+++++++++[<---------->-]<
-----.---.>>>[>+>+<<-]>>[<<+>>-]<[<<<<<.>>>>>-]<<<<<<.>>>+++
+[<++++++>-]<--.>++++[<++++++++>-]<++.>+++++[<+++++++++>-]<.
><+++++..--------.-------.>>[>>+>+<<<-]>>>[<<<+>>>-]<[<<<<++
++++++++++++.>>>>-]<<<<[-]>++++[<++++++++>-]<.>+++++++++[<++
+++++++>-]<--.---------.>+++++++[<---------->-]<.>++++++[<++
+++++++++>-]<.+++..+++++++++++++.>++++++++++[<---------->-]<
-.---.>+++++++[<++++++++++>-]<++++.+++++++++++++.++++++++++.
------.>+++++++[<---------->-]<+.>++++++++[<++++++++++>-]<-.
-.---------.>+++++++[<---------->-]<+.>+++++++[<++++++++++>-
]<--.+++++++++++.++++++++.---------.>++++++++[<---------->-]
<++.>+++++[<+++++++++++++>-]<.+++++++++++++.----------.>++++
+++[<---------->-]<++.>++++++++[<++++++++++>-]<.>+++[<----->
-]<.>+++[<++++++>-]<..>+++++++++[<--------->-]<--.>+++++++[<
++++++++++>-]<+++.+++++++++++.>++++++++[<----------->-]<++++
.>+++++[<+++++++++++++>-]<.>+++[<++++++>-]<-.---.++++++.----
---.----------.>++++++++[<----------->-]<+.---.[-]<<<->[-]>[
-]<<[>+>+<<-]>>[<<+>>-]>>>[-]<<<+++++++++<[>>>+<<[>+>[-]<<-]
>[<+>-]>[<<++++++++++>>>+<-]<<-<-]+++++++++>[<->-]>>+>[<[-]<
<+>>>-]>[-]+<<[>+>-<<-]<<<[>>+>+<<<-]>>>[<<<+>>>-]<>>[<+>-]<
<-[>[-]<[-]]>>+<[>[-]<-]<++++++++[<++++++<++++++>>-]>>>[>+>+
<<-]>>[<<+>>-]<[<<<<<.>>>>>-]<<<<<<.>>[-]>[-]++++[<++++++++>
-]<.>++++[<++++++++>-]<++.>+++++[<+++++++++>-]<.><+++++..---
-----.-------.>>[>>+>+<<<-]>>>[<<<+>>>-]<[<<<<++++++++++++++
.>>>>-]<<<<[-]>++++[<++++++++>-]<.>+++++++++[<+++++++++>-]<-
-.---------.>+++++++[<---------->-]<.>++++++[<+++++++++++>-]
<.+++..+++++++++++++.>++++++++[<---------->-]<--.>+++++++++[
<+++++++++>-]<--.-.>++++++++[<---------->-]<++.>++++++++[<++
++++++++>-]<++++.------------.---.>+++++++[<---------->-]<+.
>++++++++[<+++++++++++>-]<-.>++[<----------->-]<.+++++++++++
..>+++++++++[<---------->-]<-----.---.+++.---.[-]<<<]
@

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


typedef struct bfptrStruct {
    char *ptr;
    int pos;
    int size;
} *bfptr;


int fetchSrc(char **src, const char *filename);
bfptr getPtr(int size);

int fileLengthSeekHack(const char *filename);
int mystrlen(char *str);
void myrealloc(char *ptr, int offset, int size);

void eval(bfptr bf, char *src, int srclen);


int main(int argc, char **argv) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <brainfuck-srcfile>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    char *src;
    int len = fetchSrc(&src, argv[1]);  /* fills src and returns strlen(src) */
    bfptr bf = getPtr(64);

    eval(bf, src, len);

    return EXIT_SUCCESS;
}

bfptr getPtr(int size) {
    bfptr bf = malloc(sizeof(struct bfptrStruct));
    bf->ptr = calloc(size, sizeof(char));
    /* calloc() ( other than malloc() ) initializes the memory to zeros */
    if (bf->ptr == NULL) {
        fprintf(stderr, "Couldn't allocate memory for ptr\n");
        exit(EXIT_FAILURE);
    }
    bf->size = size;
    bf->pos = 0;
    return bf;
}

int fetchSrc(char **src, const char *filename) {
    int filesize = fileLengthSeekHack(filename);

    FILE *fd;
    fd = fopen(filename, "r");
    if (fd == NULL) {
        fprintf(stderr, "Couldn't open %s for reading.\n", filename);
        exit(EXIT_FAILURE);
    }

    *src = malloc(filesize); /* now that should be enough in every case (i guess) */
    int i = 0;
    char c;
    while ((c = fgetc(fd)) != EOF) {
        if (
            c == '+'
         || c == '-'
         || c == '<'
         || c == '>'
         || c == '['
         || c == ']'
         || c == '.'
         || c == ','
        ) {
            (*src)[i] = c;
            i++;
        }
    }
    (*src)[i] = '\0';
    return i;
}

void eval(bfptr bf, char *src, int srclen) {
    int i;
    for (i = 0; src[i]; i++) {
        switch(src[i]) {
            case '.': {
                fputc(bf->ptr[bf->pos], stdout);
                break;
            }
            case ',': {
                bf->ptr[bf->pos] = fgetc(stdin);
                break;
            }
            case '+': {
                bf->ptr[bf->pos]++;
                break;
            }
            case '-': {
                bf->ptr[bf->pos]--;
                break;
            }
            case '<': {
                if (bf->pos == 0) {
                    break;
                }
                bf->pos--;
                break;
            }
            case '>': {
                if (bf->pos == (bf->size - 1)) {
                    myrealloc(bf->ptr, bf->size, bf->size * 2);
                    bf->size *= 2;
                }
                bf->pos++;
                break;
            }
            case '[': {
                char *whileStack = malloc(srclen - i);
                i++;    /* now src[i] is one after the '[' */
                int j = 0;
                int openc = 1;
                for (; openc > 0; i++, j++) {
                    if (src[i] == '[') {
                        openc++;
                    }
                    if (src[i] == ']') {
                        openc--;
                        if (openc == 0) {
                            break;  /* break out of the for-loop */
                        }
                    }
                    whileStack[j] = src[i];
                }
                whileStack[j] = '\0';
                int whileLen = mystrlen(whileStack);
                while (bf->ptr[bf->pos]) {
                    eval(bf, whileStack, whileLen);
                }
                break;
            }
        }
    }
    return;
}

int mystrlen(char *str) {
    int i = 0;
    while (str[i]) {
        i++;
    }
    i++;
    return i;
}

void myrealloc(char *ptr, int offset, int size) {
    if (realloc(ptr, size) == NULL) {
        fprintf(stderr, "Couldn't allocate memory for ptr\n");
        exit(EXIT_FAILURE);
    }
    int i;
    for (i = offset; i < size; i++) {
        ptr[i] = 0;
    }
    return;
}

int fileLengthSeekHack(const char *filename) {
    int endpos;
    FILE *fd = fopen(filename, "rb");
    if (fd == NULL) {
        fprintf(stderr, "Couldn't open %s for read access\n", filename);
        exit(EXIT_FAILURE);
    }
    fseek(fd, 0, SEEK_END);
    endpos = ftell(fd);
    fclose(fd);
    return endpos;
}

import Char

parse :: String -> String
parse s = fst (prs s [0] 0)
	where	prs :: String -> [Int] -> Int -> (String,([Int],Int))
		prs [] a i = ([],(a,i))
		prs ('>':xs) a i = prs xs (a++[0]) (i+1)
		prs ('<':xs) a i | i > 0 = prs xs a (i-1)
				 | otherwise = error "index gets negative!"
		prs ('+':xs) a i = prs xs (inc a i) i
		prs ('-':xs) a i = prs xs (dec a i) i
		prs ('.':xs) a i = ((echoChr a i):(fst parsed),snd parsed)
			where	parsed = prs xs a i
		prs ('[':xs) a i = ((whileout ++ outnew),snd parsed)
			where 	wparsed = while xs a i
				whileout = fst wparsed
				whilea = (fst.snd) wparsed
				whilei = (snd.snd) wparsed
				parsed = prs (skipwhile xs) whilea whilei
				outnew = fst parsed
		prs (']':xs) a i = ([],(a,i))
		prs (_:xs) a i = prs xs a i

		index :: [Int] -> Int -> Int
		index (x:xs) 0 = x
		index (x:xs) i	| i > 0 = index xs (i-1)
				| otherwise = error "negative index!"

		inc :: [Int] -> Int -> [Int]
		inc (x:xs) 0 = (x+1):xs
		inc (x:xs) i 	| i > 0 = x:(inc xs (i-1))
				| otherwise = error "negative index!"

		dec :: [Int] -> Int -> [Int]
		dec (x:xs) 0 = (x-1):xs
		dec (x:xs) i 	| i > 0 = x:(dec xs (i-1))
				| otherwise = error "negative index!"

		echoChr :: [Int] -> Int -> Char
		echoChr (x:xs) 0 | x >= 0 = chr x
				 | otherwise = error "Can't display negative number!"
		echoChr (x:xs) i | i > 0 = echoChr xs (i-1)
				 | otherwise = error "negative index!"
		
		while :: String -> [Int] -> Int -> (String,([Int],Int))
		while xs a i 	| index a i == 0 = ([],(a,i))
				| otherwise = ((outnew ++ (fst wparsed)),(whilea,whilei))
					where 	wparsed = while xs anew inew
						whilea = (fst.snd) wparsed
						whilei = (snd.snd) wparsed
						parsed = prs xs a i
						outnew = fst parsed
						anew = (fst.snd) parsed
						inew = (snd.snd) parsed

		skipwhile :: String -> String
		skipwhile (']':xs) = xs
		skipwhile (_:xs) = skipwhile xs

helloWorld :: String
helloWorld = "++++++++[>+++++++++<-]>.<+++++[>++++++<-]>-.+++++++..+++.<++++++++[>>++++<<-]>>.<<++++[>------<-]>.<++++[>++++++<-]>.+++.------.--------.>+."