DouKaku?

import scala.io.Source.fromFile

object BF{
  def main(args:Array[String]) = {
    if(args.size == 0) print("scala BF [sourcecode filename]")
    else
    args.foreach{f=> (new Machine).interpret(fromFile(f).mkString("")) }
  }
}

object Machine {
  final val MEM = 0xffffff
  final val VAL = 0xff
}

class Machine{
  var _p = 0
  val _mem = new Array[int](Machine.MEM)
  def p_=(v:int) = _p = v&Machine.MEM
  def p = _p
  def mem_=(v:int) = _mem(p)=v&Machine.VAL
  def mem = _mem(p)

  def abort = error("Missing corresponding parenthesis.")

  def interpret(code:String):unit = interpret(code.toArray)
  def interpret(code:Array[char]):unit = {
    val (s,m) = ((List[int](), List[(int,int)]()) /: code.zipWithIndex){
      (r,c) => c._1 match {
        case '[' => (c._2::r._1, r._2)
        case ']' => r._1 match {
          case x::xs => (xs, (x,c._2)::(c._2,x)::r._2)
          case _ => abort
        }
        case _   => r
    }}
    if(s.size > 0) abort
    val parenMap = Map(m:_*)

    var i = -1;while({i=i+1;i<code.size}) code(i) match {
      case '>' => p = p+1
      case '<' => p = p-1
      case '+' => mem = mem+1
      case '-' => mem = mem-1
      case '.' => print(mem.asInstanceOf[char])
      case ',' => mem = readChar.asInstanceOf[int]
      case '[' if mem == 0 => i = parenMap(i)
      case ']' if mem != 0 => i = parenMap(i)
      case _   => ()
    }
  }
}

using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using Microsoft.CSharp;
static class BFCompiler {
    public static void Main(String[] args) {
        if (0 < args.Length && File.Exists(args[0])) {
            using(StringWriter sw = new StringWriter())
            using(StreamReader sr = new StreamReader(args[0])) {
                Stack<string> labels = new Stack<string>();
                int label_num = 0;
                sw.WriteLine("using System; static class BF {");
                sw.WriteLine("public static void Main() {");
                sw.WriteLine("byte[] m = new byte[256]; int p = 0;");
                foreach(char c in sr.ReadToEnd()) {
                    switch(c) {
                        case '+': sw.WriteLine("m[p]++;"); break;
                        case '-': sw.WriteLine("m[p]--;"); break;
                        case '>': sw.WriteLine("p++;"); break;
                        case '<': sw.WriteLine("p--;"); break;
                        case '.': sw.WriteLine("Console.Write((char)m[p]);"); break;
                        case ',': sw.WriteLine("m[p] = (byte)Console.Read();"); break;
                        case '[': {
                            string ll = "L" + (label_num++);
                            labels.Push(ll);
                            sw.WriteLine("if (m[p] == 0) goto {0}_END;", ll);
                            sw.WriteLine("{0}_START:;", ll);
                            break;
                        }
                        case ']': {
                            string ll = labels.Pop();
                            sw.WriteLine("if (m[p] != 0) goto {0}_START;", ll);
                            sw.WriteLine("{0}_END:;", ll);
                            break;
                        }
                    }
                }
                sw.WriteLine("}}");
                Generate(Path.GetFileNameWithoutExtension(args[0]), sw.ToString());
            }
        }
        else {
            Console.WriteLine("usage: bfc [sourcefile]");
        }
    }
    private static void Generate(string filename, string cs_code) {
        // ソースファイル生成
        using (StreamWriter sw = new StreamWriter(filename + ".cs")) {
            sw.Write(cs_code);
        }
        // 実行ファイル生成
        CompilerParameters param = new CompilerParameters();
        param.OutputAssembly = filename + ".exe";
        param.GenerateExecutable = true;
        CompilerResults rs = new CSharpCodeProvider().CompileAssemblyFromSource(param, cs_code);
        // 実行
        rs.CompiledAssembly.GetType("BF").GetMethod("Main").Invoke(null, null);
    }
}

perl -MLanguage::BF \
  -e 'print Language::BF->new_from_file(shift)->as_perl' t/hello.bf \
  | perl
Hello World!

import sys
from getopt import getopt

def encode(bfcode):
    depth = code = 0
    pycode = []
    stack = []
    
    f = file(default['-o'], 'w')
    
    pycode.append('import sys')
    pycode.append('tape, ptr, code = {}, 0, 0')
    
    while code != len(bfcode):
        c = bfcode[code]
        
        if c == '>':
            pycode.append('\t' * depth + 'ptr += 1')
        elif c == '<':
            pycode.append('\t' * depth + 'ptr -= 1')
        elif c == '+':
            pycode.append('\t' * depth + 'tape[ptr] = tape.get(ptr, 0) + 1')
        elif c == '-':
            pycode.append('\t' * depth + 'tape[ptr] = tape.get(ptr, 0) - 1')
        elif c == ',':
            pycode.append('\t' * depth + 'tape[ptr] = sys.stdin.read(1)')
        elif c == '.':
            pycode.append('\t' * depth + 'sys.stdout.write(chr(tape.get(ptr, 0)))')
        elif c == '[':
            pycode.append('\t' * depth + 'while tape.get(ptr, 0):')
            stack.append(depth)
            depth += 1
        elif c == ']':
            depth = stack.pop()
        
        code += 1
    
    file(default['-o'], 'w').write('\n'.join(pycode))


if __name__ == '__main__':
    default = {'-o': 'a.py'}
    optlist, args = getopt(sys.argv[1:], 'o:', [])
    if args:
        default.update(optlist)
        encode(''.join(file(args[0]).readlines()))

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

int main(int arg_c, char **arg_v) {
    FILE *fp;
    int c;

    if (*++arg_v == NULL) {
        fprintf(stderr, "usage: bfc [source file]\n");
        exit(EXIT_FAILURE);
    }
    if ((fp = fopen(*arg_v, "r")) == NULL) {
        fprintf(stderr, "file open error.\n");
        exit(EXIT_FAILURE);
    }
    
    puts("#include <stdio.h>");
    puts("#include <stdlib.h>");
    puts("int main(void) {");
    puts(" char *s, *p;");
    puts(" p = s = (char *)calloc(1024, 1);");
    
    while ((c = getc(fp)) != EOF) {
        switch (c) {
            case '>': puts(" ++p;"); break;
            case '<': puts(" --p;"); break;
            case '+': puts(" ++*p;"); break;
            case '-': puts(" --*p;"); break;
            case '.': puts(" putchar(*p);"); break;
            case ',': puts(" *p = getchar();"); break;
            case '[': puts(" while (*p) {"); break;
            case ']': puts(" }"); break;
            default: break;
        }
    }
    
    puts(" free(s);");
    puts("}");
    
    fclose(fp);
}

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

char *code[] = { "sp++;", "sp--;", "(*sp)++;", "(*sp)--;", "putchar(*sp);",
                 "*sp = getchar();", "while(*sp){", "}" };

int main( int argc, char *argv[] ){
   int c,i,j,n=0;
   int indent = 1;
   int length;
   FILE *fp;

   if( argc < 2 ){
      fprintf(stderr,"Usage: %s sourcefile\n", argv[0] );
      return EXIT_FAILURE;
   }
   if( (fp = fopen( argv[1], "r" )) == NULL ){
      fprintf(stderr,"Error: %s cannot opened\n", argv[1] );
      return EXIT_FAILURE;
   }
   if( !argv[2] || (length = atoi( argv[2] )) <= 0 ){
      length = 256;
   }

   puts("#include <stdio.h>");
   puts("#include <stdlib.h>");
   printf("#define DATA_LEN %d\n", length);
   puts("char code[DATA_LEN];");
   puts("int main (void){");
   puts("   char *sp = code;");
   while( (c=fgetc( fp )) != EOF ){
      switch(c){
      case '>': i = 0; break;
      case '<': i = 1; break;
      case '+': i = 2; break;
      case '-': i = 3; break;
      case '.': i = 4; break;
      case ',': i = 5; break;
      case '[': i = 6; indent++; break;
      case ']': i = 7; indent--; break;
      default:
         /* skip other characters */
         continue;
      }
      for( j = 0; j < (indent+(i==6?-1:0)); j++ ){
         printf("   ");
      }
      printf("%s\n", code[i] );
   }
   puts("   return EXIT_SUCCESS;");
   puts("}");
   fclose(fp);
   return EXIT_SUCCESS;
}

(defun compile-bf (str &optional (size 30000) (offset 0))
  (let ((tags ()))
    (flet ((translate (c)
             (case c
               (#\> '((incf ptr)))
               (#\< '((decf ptr)))
               (#\+ '((setf *ptr (logand (1+ *ptr) #xff))))
               (#\- '((setf *ptr (logand (1- *ptr) #xff))))
               (#\. '((write-char (code-char *ptr))))
               (#\, '((setf *ptr (char-code (read-char)))))
               (#\[ (let ((t1 (gensym)) (t2 (gensym)))
                      (setf tags (list* t1 t2 tags))
                      `(,t1 (if (= *ptr 0) (go ,t2)))))
               (#\] (let ((t1 (pop tags)) (t2 (pop tags)))
                      `((if (/= *ptr 0) (go ,t1)) ,t2))))))
      `(symbol-macrolet ((*ptr (aref array ptr)))
         (prog ((array ,(make-array size :initial-element 0))
                (ptr ,offset))
           ,@(loop for c across str append (translate c)))))))

;;; test
(eval (compile-bf "+++++++++[>++++++++>+++++++++++>+++++<<<-]>.>++.
+++++++..+++.>-.------------.<++++++++.--------.+++.------.--------.>+."))

import scala.io.Source.fromFile

object BFC{
  def main(args:Array[String]) = {
    if(args.size == 0){
      println("Usage:scala BFC [sourcecode filename]")
    }else{
      println("""
        object Machine {
          final val MEM = 0xffffff
          final val VAL = 0xff
        }

        class Machine{
          var _p = 0
          val _mem = new Array[int](Machine.MEM)
          def p_=(v:int) = _p = v&Machine.MEM
          def p = _p
          def mem_=(v:int) = _mem(p)=v&Machine.VAL
          def mem = _mem(p)

          def eval = {
      """)
      val code = fromFile(args(0)).mkString("").toList
      if(code.count('['==_) != code.count(']'==_)) {
        error("Missing corresponding parenthesis.")
      }
      code.foreach(c=>println(c match {
        case '>' => "p = p+1"
        case '<' => "p = p-1"
        case '+' => "mem = mem+1"
        case '-' => "mem = mem-1"
        case '.' => "print(mem.asInstanceOf[char])"
        case ',' => "mem = readChar.asInstanceOf[int]"
        case '[' => "while(mem != 0){"
        case ']' => "}"
        case _   => ""
      }))
      println("}};(new Machine).eval;")
    }
  }
}

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

int main( int argc, char *argv[] ){
    int c;
    char *code[256];
    int length;
    FILE *fp;

    if( argc < 2 ){
        fprintf(stderr,"Usage: %s sourcefile\n", argv[0] );
        return EXIT_FAILURE;
    }
    if( (fp = fopen( argv[1], "r" )) == NULL ){
        fprintf(stderr,"Error: %s cannot opened\n", argv[1] );
        return EXIT_FAILURE;
    }
    if( !argv[2] || (length = atoi( argv[2] )) <= 0 ){
        length = 256;
    }

    for (c = 0; c < 256; c++) code[c] = NULL;
    code['>'] = "sp++;";
    code['<'] = "sp--;";
    code['+'] = "(*sp)++;";
    code['-'] = "(*sp)--;";
    code['.'] = "putchar(*sp);";
    code[','] = "*sp = getchar();";
    code['['] = "while(*sp){";
    code[']'] = "}";

    puts("#include <stdio.h>");
    puts("#include <stdlib.h>");
    printf("#define DATA_LEN %d\n", length);
    puts("char code[DATA_LEN];");
    puts("int main (void){");
    puts("   char *sp = code;");
    while( (c=fgetc( fp )) != EOF ) if (code[c]) printf("%s\n", code[c]); 
    puts("   return EXIT_SUCCESS;");
    puts("}");
    fclose(fp);
    return EXIT_SUCCESS;
}

class BF
  def compile(str)
    depth = 0
    code = []
    code << "mem = [0]"
    code << "ptr = 0"
    str.each_byte do |ch|   
      if ch == ?>
        code << "\t" * depth + "ptr += 1; mem[ptr] = 0 if ptr >= mem.size"
      elsif ch == ?<
        code << "\t" * depth + "(ptr == 0)? mem.unshift(0) : ptr -= 1"
      elsif ch == ?+
        code << "\t" * depth + "mem[ptr] += 1"
      elsif ch == ?-
        code << "\t" * depth + "mem[ptr] -= 1"
      elsif ch == ?.
        code << "\t" * depth + "putc(mem[ptr])"
      elsif ch == ?,
        code << "\t" * depth + "mem[ptr] = STDIN.getc"
      elsif ch == ?[
        code << "\t" * depth + "while(mem[ptr] != 0) do"
        depth += 1
      elsif ch == ?]
        depth -= 1
        code << "\t" * depth + "end"
      end
    end
   code.join "\n"
  end
end

eval BF.new.compile("++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.") # => Hello World!

def encode(bfcode):
-   depth = code = 0 
+   depth = 0
    pycode = []
    stack = []
    
    f = file(default['-o'], 'w')
    
    pycode.append('import sys')
-   pycode.append('tape, ptr, code = {}, 0, 0')
+   pycode.append('tape, ptr = {}, 0')
    

-     while code != len(bfcode):
-        c = bfcode[code]
+     for c in bfcode:
        if c == '>':
            pycode.append('\t' * depth + 'ptr += 1')
        elif c == '<':
            pycode.append('\t' * depth + 'ptr -= 1')
        elif c == '+':
            pycode.append('\t' * depth + 'tape[ptr] = tape.get(ptr, 0) + 1')
        elif c == '-':
            pycode.append('\t' * depth + 'tape[ptr] = tape.get(ptr, 0) - 1')
        elif c == ',':
            pycode.append('\t' * depth + 'tape[ptr] = sys.stdin.read(1)')
        elif c == '.':
            pycode.append('\t' * depth + 'sys.stdout.write(chr(tape.get(ptr, 0)))')
        elif c == '[':
            pycode.append('\t' * depth + 'while tape.get(ptr, 0):')
            stack.append(depth)
            depth += 1
        elif c == ']':
+           pycode.append('\t' * depth + 'pass')
            depth = stack.pop()

-    code += 1

BEGIN {
    read_buf = ""
    if (optimize) reset_last()

    indent = ""
    indent_print("BEGIN {")

    indent_incr()
    indent_print("ix = 0")
}
{
    gsub(/#.*$/,""); # comment
    gsub(/[^\[\]<>+\-.,]/,""); if (/^$/) next

    N = split($0, op, "")
    for (i=1; i<=N; i++) {
        if (op[i] == ">") {
            if (optimize) {
                if (last_inst == "ix") {
                    last_arg++
                } else {
                    out_last()
                    set_last("ix", 1)
                }
            } else {
                indent_print("ix++")
            }
        } else if (op[i] == "<") {
            if (optimize) {
                if (last_inst == "ix") {
                    last_arg--
                } else {
                    out_last()
                    set_last("ix", -1)
                }
            } else {
                indent_print("ix--")
            }
        } else if (op[i] == "+") {
            if (optimize) {
                if (last_inst == "st[ix]") {
                    last_arg++
                } else {
                    s = set_incr_decr("st[ix]")
                    if (last_inst) out_last()
                    set_last(s, 1)
                }
            } else {
                indent_print("st[ix]++")
            }
        } else if (op[i] == "-") {
            if (optimize) {
                if (last_inst == "st[ix]") {
                    last_arg--
                } else {
                    s = set_incr_decr("st[ix]")
                    if (last_inst) out_last()
                    set_last(s, -1)
                }
            } else {
                indent_print("st[ix]--")
            }
        } else if (op[i] == ".") {
            if (optimize) {
                s = set_incr_decr("printf(\"%c\", st[ix])")
                if (last_inst) out_last()
                indent_print(s)
            } else {
                indent_print("printf(\"%c\", st[ix])")
            }
        } else if (op[i] == ",") {
            if (optimize) {
                s = set_incr_decr("st[ix] = getchar()")
                if (last_inst) out_last()
                indent_print(s)
            } else {
                indent_print("st[ix] = getchar()")
            }
        } else if (op[i] == "[") {
            if (optimize) {
                s = set_incr_decr("while (st[ix]) {")
                if (last_inst) out_last()
                indent_print(s)
                indent_incr()
            } else {
                indent_print("while (st[ix]) {")
                indent_incr()
            }
        } else if (op[i] == "]") {
            if (optimize) out_last()
            indent_decr()
            indent_print("}")
        } else {
            ;
        }
    }
}
END {
    if (optimize) out_last()
    indent_decr()
    indent_print("}")
}

function getchar(  ch)
{
    if (read_buf ~ /^$/) getline read_buf
    ch = substr(read_buf,1,1)
    read_buf = substr(read_buf,2)
    return ch
}
function indent_incr()
{
    indent = "  " indent
}
function indent_decr()
{
    indent = substr(indent, 3)
}
function indent_print(line)
{
    print indent line
}
function set_last(inst,arg)
{
    last_inst = inst
    last_arg = arg
}
function reset_last()
{
    last_inst = ""
    last_arg = 0
}
function out_last(  diff)
{
    if (last_inst ~ /ix/) {
        if (last_arg > 1)
            diff = " += " last_arg
        else if (last_arg == 1)
            diff = "++"
        else if (last_arg == 0)
            diff = ""
        else if (last_arg == -1)
            diff = "--"
        else if (last_arg < -1)
            diff = " -= " (0 - last_arg)

        if (diff) indent_print(last_inst diff)
    }
    last_inst = ""
}
function set_incr_decr(s)
{
    if (last_inst == "ix") {
        if (last_arg == 1) { gsub(/ix/, "++ix", s); last_inst = "" }
        else if (last_arg == -1) { gsub(/ix/, "--ix", s); last_inst = "" }
    }
    return s
}

class BF
  @@opcode = {
    '>' => "ptr += 1; mem[ptr] = 0 if ptr >= mem.size",
    '<' => "(ptr == 0)? mem.unshift(0) : ptr -= 1",
    '+' => "mem[ptr] += 1",
    '-' => "mem[ptr] -= 1",
    '.' => "putc(mem[ptr])",
    ',' => "mem[ptr] = STDIN.getc",
    '[' => "while(mem[ptr] != 0) do",
    ']' => "end"
  }
  def compile(str)
    code = ["mem = [0]", "ptr = 0"]
    str.unpack("C*").map{|c| c.chr}.each do |ch|
      next unless @@opcode[ch]
      code << @@opcode[ch]
    end
   code.join "\n"
  end
end

| bf st op in |
bf := FileStream fileNamed: 'hello.bf'.
in := FileStream fileNamed: 'in.txt'.
in binary.
st := WriteStream with: '| ss | ss := ReadWriteStream with: #(0). ss reset'.
[(op := bf next) notNil] whileTrue: [
    st nextPutAll: (op caseOf: {
        [$>] -> ['. ss next. ss atEnd ifTrue: [ss nextPut: 0; back]'].
        [$<] -> ['. ss back'].
        [$+] -> ['. ss nextPut: ss peek + 1; back'].
        [$-] -> ['. ss nextPut: ss peek - 1; back'].
        [$.] -> ['. Transcript show: (ss peek asCharacter)'].
        [$,] -> ['. ss nextPut: ', in next printString,' value; back'].
        [$[] -> ['. [ss peek isZero] whileFalse: ['].
        [$]] -> [']']} otherwise: [''])].
bf close.  in close.
World findATranscript: nil.
Compiler evaluate: st contents

% awk -f bfcc.awk helloworld.bf | a2p | perl
Hello, World!

--- bf2awk.awk.orig    2007-11-14 00:43:07.000000000 +0900
+++ bf2awk.awk    2007-11-14 01:46:46.000000000 +0900
@@ -77,15 +77,9 @@
                 indent_print("st[ix] = getchar()")
             }
         } else if (op[i] == "[") {
-            if (optimize) {
-                s = set_incr_decr("while (st[ix]) {")
-                if (last_inst) out_last()
-                indent_print(s)
-                indent_incr()
-            } else {
-                indent_print("while (st[ix]) {")
-                indent_incr()
-            }
+            if (optimize) out_last()
+            indent_print("while (st[ix]) {")
+            indent_incr()
         } else if (op[i] == "]") {
             if (optimize) out_last()
             indent_decr()

--- bf2awk.awk.orig    2007-11-14 00:43:07.000000000 +0900
+++ bf2awk.awk    2007-11-14 01:55:50.000000000 +0900
@@ -38,7 +38,7 @@
             }
         } else if (op[i] == "+") {
             if (optimize) {
-                if (last_inst == "st[ix]") {
+                if (last_inst ~ /^st\[/) {
                     last_arg++
                 } else {
                     s = set_incr_decr("st[ix]")
@@ -50,7 +50,7 @@
             }
         } else if (op[i] == "-") {
             if (optimize) {
-                if (last_inst == "st[ix]") {
+                if (last_inst ~ /^st\[/) {
                     last_arg--
                 } else {
                     s = set_incr_decr("st[ix]")

,+[-.,+]

#!/usr/bin/env python
import sys
from getopt import getopt

def bf2py(bfcode):
    depth = 0
    opcode = {
        '>':'ptr += 1',
        '<':'ptr -= 1',
        '+':'tape[ptr] = tape.get(ptr, 0) + 1',
        '-':'tape[ptr] = tape.get(ptr, 0) - 1',
        ',':'tape[ptr] = sys.stdin.read(1)',
        '.':'sys.stdout.write(chr(tape.get(ptr, 0)))',
        '[':'while tape.get(ptr, 0):',
        ']':'pass'
    }
    pycode = []
    stack = []
    
    pycode.append('import sys')
    pycode.append('tape, ptr = {}, 0')
    
    for c in bfcode:
        if opcode.has_key(c):
            pycode.append( '\t' * depth + opcode[c])
            if c == '[':
                stack.append(depth)
                depth += 1
            elif c == ']':
                depth = stack.pop()
     
    return '\n'.join(pycode)

if __name__ == '__main__':
    defout = 'a.py'
    optlist, args = getopt(sys.argv[1:], 'o:', [])
    if args:
        pysrc = bf2py(''.join(file(args[0]).readlines()));
        file(defout or ops['-o'], 'w').write(pysrc)

BEGIN {
    if (optimize) reset_last()

    indent = ""
    print "BEGIN {"

    indent_incr()
    indent_print("read_buf = \"\"")
    indent_print("ix = 0")
}
{
    gsub(/#.*$/,""); # comment
    gsub(/[^\[\]<>+\-.,]/,""); if (/^$/) next

    N = split($0, op, "")
    for (i=1; i<=N; i++) {
        if (op[i] == ">") {
            if (optimize) {
                if (last_inst == "ix") {
                    last_arg++
                } else {
                    out_last()
                    set_last("ix", 1)
                }
            } else {
                indent_print("ix++")
            }
        } else if (op[i] == "<") {
            if (optimize) {
                if (last_inst == "ix") {
                    last_arg--
                } else {
                    out_last()
                    set_last("ix", -1)
                }
            } else {
                indent_print("ix--")
            }
        } else if (op[i] == "+") {
            if (optimize) {
                if (last_inst ~ /^st\[/) {
                    last_arg++
                } else {
                    s = set_incr_decr("st[ix]")
                    if (last_inst) out_last()
                    set_last(s, 1)
                }
            } else {
                indent_print("st[ix]++")
            }
        } else if (op[i] == "-") {
            if (optimize) {
                if (last_inst ~ /^st\[/) {
                    last_arg--
                } else {
                    s = set_incr_decr("st[ix]")
                    if (last_inst) out_last()
                    set_last(s, -1)
                }
            } else {
                indent_print("st[ix]--")
            }
        } else if (op[i] == ".") {
            if (optimize) {
                s = set_incr_decr("printf(\"%c\", st[ix])")
                if (last_inst) out_last()
                indent_print(s)
            } else {
                indent_print("printf(\"%c\", st[ix])")
            }
        } else if (op[i] == ",") {
            if (optimize) {
                s = set_incr_decr("st[ix] = getchar()")
                if (last_inst) out_last()
                indent_print(s)
            } else {
                indent_print("st[ix] = getchar()")
            }
        } else if (op[i] == "[") {
            if (optimize) {
                s = set_incr_decr("while (st[ix]) {")
                if (last_inst) out_last()
                indent_print(s)
                indent_incr()
            } else {
                indent_print("while (st[ix]) {")
                indent_incr()
            }
        } else if (op[i] == "]") {
            if (optimize) out_last()
            indent_decr()
            indent_print("}")
        } else {
            ;
        }
    }
}
END {
    if (optimize) out_last()
    indent_decr()
    indent_print("}")

    print "function getchar(  ch)"
    print "{"
    print "  if (read_buf ~ /^$/) {"
    print "    if (eof) return -1"
#    print "    if ((getline read_buf) < 1) { eof = 1; return -1 }"
    print "    if (getline != 1) { eof = 1; return -1 }" # a2p
    print "    read_buf = $0" # a2p
    print "  }"
    print "  ch = ord(substr(read_buf,1,1))"
    print "  read_buf = substr(read_buf,2)"
    print "  return ch"
    print "}"

    print "function ord(ch, ofs)"
    print "{"
    print "  if (ch == \"\\t\") return 9"
    print "  if (ch == \"\\n\") return 13"
#    print "  ofs = index(\" !\\\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\", ch)"
    print "  if (ch == \"@\") return 64" # a2p
    print "  ofs = index(\" !\\\"#$%&'()*+,-./0123456789:;<=>?.ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\", ch)" # a2p
    print "  return ofs ? 31 + ofs : 0"
    print "}"
}

function indent_incr()
{
    indent = "  " indent
}
function indent_decr()
{
    indent = substr(indent, 3)
}
function indent_print(line)
{
    print indent line
}
function set_last(inst,arg)
{
    last_inst = inst
    last_arg = arg
}
function reset_last()
{
    last_inst = ""
    last_arg = 0
}
function out_last(  diff)
{
    if (last_inst ~ /ix/) {
        if (last_arg > 1)
            diff = " += " last_arg
        else if (last_arg == 1)
            diff = "++"
        else if (last_arg == 0)
            diff = ""
        else if (last_arg == -1)
            diff = "--"
        else if (last_arg < -1)
            diff = " -= " (0 - last_arg)

        if (diff) indent_print(last_inst diff)
    }
    last_inst = ""
}
function set_incr_decr(s)
{
    if (last_inst == "ix") {
        if (last_arg == 1) { gsub(/ix/, "++ix", s); last_inst = "" }
        else if (last_arg == -1) { gsub(/ix/, "--ix", s); last_inst = "" }
    }
    return s
}

function BF(code){
  var s = '', o = {
    '>': 'm[p+=?]|=0;',
    '<': 'm[p-=?]|=0;',
    '+': 'm[p]+=?;',
    '-': 'm[p]-=?;',
    ',': 'm[p]=get().charCodeAt(0);',
    '.': 'put(c(m[p]));',
    '[': 'while(m[p]){',
    ']': '}' };
  code.replace(/>+|<+|\++|-+|([,.[\]])/g, function($, _){
    s += _ ? o[$] : o[$.charAt(0)].replace('?', $.length) });
  return eval('0,function(get,put){var m=[0],p=0,c=String.fromCharCode;'+ s +'}');
}
/// Rhinoで「hello world」のテスト ///
BF('++++++++++[>+++++++>++++++++++>+++>+<<<<-]\
    >++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.'
)(function(){ return '?' }, function(c){ java.lang.System.out.print(c) });

/// WSHで「echo」のテスト ///
//BF(',+[-.,+]')(function(){ return WSH.stdIn.read(1) }, function(c){ WSH.stdOut.write(c) });

import Data.List
import System.Environment

putCode '>' = putStr "incP >=> "
putCode '<' = putStr "decP >=> "
putCode '+' = putStr "inc >=> " 
putCode '-' = putStr "dec >=> " 
putCode '.' = putStr "put >=> " 
putCode ',' = putStr "get >=> " 
putCode '[' = putStr "loop("
putCode ']' = putStr "return) >=> "

genCode source 
    = do putStr "runBF = "
         mapM_ putCode (source `intersect` "><+-.,[]")
         putStrLn "return"

main = do
    source <- readFile . head =<< getArgs

    putStrLn "import Data.Char"
    putStrLn "(>=>) m1 m2 = \\s -> m1 s >>= m2"
    putStrLn "incP (ps, n:ns)    = return (n:ps, ns)"
    putStrLn "decP (p:ps, ns)    = return (ps, p:ns)"
    putStrLn "inc (ps, n:ns)     = return (ps, n+1:ns)"
    putStrLn "dec (ps, n:ns)     = return (ps, n-1:ns)"
    putStrLn "put mem@(_, n:_)   = putChar (chr n) >> return mem"
    putStrLn "get mem@(ps, _:ns) = getChar >> (\\c -> return (ps, ord c:ns))"
    putStrLn "loop code mem@(_, 0:_) = return mem"
    putStrLn "loop code mem = code mem >>= loop code"
    genCode source
    putStrLn "main = runBF ([0,0..], [0,0..])"

/*
    出力例
#include <stdio.h>
static int stack[32768];
static const unsigned char code[] = {
0x55,0x56,0x57,0x8b,0x74,0x24,0x10,0x8b,0x7c,0x24,0x14,0x8b,0x6c,0x24,0x18,0x83,
...
};
main()
{
    ((void (*)(void*, void*, int *))code)((void*)putchar, (void*)getchar, stack);
}

*/
#include "xbyak/xbyak.h"
#include <stdio.h>
#include <stack>
#include <fstream>

struct Brainfuck : public Xbyak::CodeGenerator {
    Brainfuck(std::istream& is) : CodeGenerator(10000)
    {
        push(ebp); // stack
        push(esi);
        push(edi);
        const int _P = 4 * 3;
        mov(esi, ptr[esp + _P + 4]);
        mov(edi, ptr[esp + _P + 8]);
        mov(ebp, ptr[esp + _P + 12]);
        int labelNo = 0;
        std::stack<int> keepLabelNo;
        char label[32];
        char c;
        while (is >> c) {
            switch (c) {
            case '+': inc(dword [ebp]); break;
            case '-': dec(dword [ebp]); break;
            case '.': push(dword [ebp]); call(esi); pop(eax); break;
            case ',': call(edi); mov(dword [ebp], eax); break;
            case '>': add(ebp, 4); break;
            case '<': sub(ebp, 4); break;
            case '[':
                sprintf(label, "B%d", labelNo); L(label);
                mov(eax, dword [ebp]);
                test(eax, eax);
                sprintf(label, "F%d", labelNo); jz(label, T_NEAR);
                keepLabelNo.push(labelNo++);
                break;
            case ']':
                {
                    int no = keepLabelNo.top(); keepLabelNo.pop();
                    sprintf(label, "B%d", no); jmp(label);
                    sprintf(label, "F%d", no); L(label);
                }
                break;
            default:
                break;
            }
        }
        pop(edi);
        pop(esi);
        pop(ebp);
        ret();
    }
};

void dump(const Xbyak::uint8 *code, size_t size)
{
    puts("#include <stdio.h>\nstatic int stack[32768];\nstatic const unsigned char code[] = {");
    for (size_t i = 0; i < size; i++) {
        printf("0x%02x,", code[i]); if ((i % 16) == 15) putchar('\n');
    }
    puts("\n};");
#ifdef __linux__
    puts("#include <unistd.h>");
    puts("#include <sys/mman.h>");
#endif
    puts("main()\n{");
#ifdef __linux__
    puts("\tlong pageSize = sysconf(_SC_PAGESIZE) - 1;");
    puts("\tmprotect((void*)code, (sizeof(code) + pageSize) & ~pageSize, PROT_READ | PROT_EXEC);");
#endif
    puts(
        "\t((void (*)(void*, void*, int *))code)((void*)putchar, (void*)getchar, stack);\n"
        "}"
    );
}

int main(int argc, char *argv[])
{
    if (argc == 1) {
        fprintf(stderr, "bf filename.bf [0|1]\n");
        return 1;
    }
    std::ifstream ifs(argv[1]);
    int mode = argc == 3 ? atoi(argv[2]) : 0; 
    Brainfuck bf(ifs);
    if (mode == 0) {
        static int stack[32768];
        ((void (*)(void*, void*, int *))bf.getCode())((void*)putchar, (void*)getchar, stack);
    } else {
        dump(bf.getCode(), bf.getSize());
    }
    return 0;
}

-- bfc.hs : BF コンパイラ ---------------------------------------------------
module Main where

import Data.Char
import Data.List
import System.IO
import System.Environment

main = do { args <- getArgs
          ; case args of
              []  -> runcompiler stdin stdout
              s:_ -> do { ih <- openFile (s++".b") ReadMode
                        ; oh <- openFile (s++".hs") WriteMode
                        ; runcompiler ih oh
                        }
          }

runcompiler ih oh =
 do { cs <- hGetContents ih
    ; let cs' = zip [0..] $ filter (not . isSpace) cs
    ; outputCode oh $ compile cs'
    }

compile [] = []
compile (c:cs) = case c of
  (_,'>') -> "incp" : compile cs
  (_,'<') -> "decp" : compile cs
  (_,'+') -> "incc" : compile cs
  (_,'-') -> "decc" : compile cs
  (_,'.') -> "putc" : compile cs
  (_,',') -> "getc" : compile cs
  (_,']') -> "jmpb" : compile cs
  (_,'[') -> ("jmpf "++show pc) : compile cs
               where pc = findpc [] cs
  _       -> error "invalid input"

findpc s []     = error "syntax error"
findpc s (c:cs) = case c of
  (_,'[') -> findpc ('[':s) cs
  (p,']') -> case s of
               [] -> p+1
               _  -> findpc (tail s) cs
  _       -> findpc s cs

outputCode h s 
 = do { hd <- readFile "bfrts.tmpl"
      ; hPutStrLn h hd
      ; hPutStrLn h "codeL :: [Instruction]"
      ; hPutStr h "codeL = ["
      ; hPutStr h (concat (intersperse "," s))
      ; hPutStr h "]\n"
      }

-- bfrts.templ : ランタイムテンプレート -------------------------------------

module Main where

import Control.Monad.State
import Data.Array as A
import Data.Char
import Data.IntMap as M
import Debug.Trace

type PC      = Int
type Code    = Array PC Instruction
type Heap    = M.IntMap Char
type Stack   = [PC]
type Pointer = Int
type VM   = (Stack,PC,Heap,Pointer)

type Instruction = VM -> StateT VM IO ()

top = head
pop = tail
push = (:)

-- initial machine state

iStat = ([],0,M.fromList $ zip [0..29999] (repeat $ chr 0),0)

-- instruction set

incp,decp,incc,decc,putc,getc,jmpb :: Instruction
jmpf :: PC -> Instruction
incp (s,c,h,p) = put (s,succ c,h,succ p)
decp (s,c,h,p) = put (s,succ c,h,pred p)
incc (s,c,h,p) = put (s,succ c,M.update (Just . succ) p h,p)
decc (s,c,h,p) = put (s,succ c,M.update (Just . pred) p h,p)
putc (s,c,h,p) = liftIO (putChar (h M.! p)) >> put (s,succ c,h,p)
getc (s,c,h,p) = liftIO (getChar >>= \ ch -> return (s,succ c,M.update (const (Just ch)) p h,p)) >>= put
jmpb (s,c,h,p) = if h M.! p == chr 0 then put (pop s,succ c,h,p) else put (s,top s,h,p)
jmpf pc (s,c,h,p) = if h M.! p == chr 0 then put (s,pc,h,p) else put (push (succ c) s,succ c,h,p)

-- run compiled bf code
             
main :: IO ()
main = evalStateT execute iStat >> putStrLn ""

run = do { stat@(s,c,h,p) <- get
         ; if inRange (bounds code) c then (code A.! c) stat >> run
           else return () 
         }

code :: Code 
code = listArray (0,length codeL - 1) codeL

-- この下にコンパイル済みの codeL :: [Instruction] が追加される

from ply import lex, yacc
import sys

# lex
tokens = "PLUS MINUS LEFT RIGHT WHILE WEND PUT GET COMMENT".split()

t_WHILE = "\["
t_WEND = "]"
t_PUT = "\."
t_GET = ","

def t_PLUS(t):
    "\++"
    t.value = len(t.value)
    return t

def t_MINUS(t):
    "-+"
    t.value = len(t.value)
    return t

def t_LEFT(t):
    "<+"
    t.value = len(t.value)
    return t

def t_RIGHT(t):
    ">+"
    t.value = len(t.value)
    return t

def t_COMMENT(t):
    '[^[\]><+-,.]' # return nothing

def t_error(t): pass
    
# yacc
"""*** grammar definition
sequence : sequence command
         | command

command : PLUS
        | MINUS
        | LEFT
        | RIGHT
        | PUT
        | GET
        | loop

loop : WHILE sequence WEND
"""

def p_sequence(p):
    "sequence : sequence command"
    p[0] = p[1] + "or " + p[2]

def p_sequence_command(p):
    "sequence : command"
    p[0] = p[1]

def p_command_PLUS(p):
    "command : PLUS"
    p[0] = "bf.inc(%s)" % p[1]

def p_command_MINUS(p):
    "command : MINUS"
    p[0] = "bf.inc(%s)" % -p[1]

def p_command_LEFT(p):
    "command : LEFT"
    p[0] = "bf.mov(%s)" % -p[1]

def p_command_RIGHT(p):
    "command : RIGHT"
    p[0] = "bf.mov(%s)" % p[1]

def p_command_PUT(p):
    "command : PUT"
    p[0] = "bf.put()"

def p_command_GET(p):
    "command : GET"
    p[0] = "bf.get()"

def p_command_loop(p):
    "command : loop"
    p[0] = p[1]
    
def p_loop(p):
    "loop : WHILE sequence WEND"
    p[0] = "bf.loop(lambda: %s)" % p[2]

def p_error(p): pass

# input and parse
data = sys.stdin.read()
lex.lex()
yacc.yacc()
result = yacc.parse(data)

# output
print """
from collections import defaultdict
import sys
class BF(object):
    mem = defaultdict(int)
    cur = 0
    def inc(self, n):
        self.mem[self.cur] += n
        self.mem[self.cur] %= 256
    def mov(self, n):
        self.cur += n
    def put(self):
        c = chr(self.mem[self.cur])
        sys.stdout.write(c)
    def get(self):
        c = sys.stdin.read(1)
        self.mem[self.cur] = ord(c)
    def loop(self, seq):
        while self.mem[self.cur]:
            seq()

bf = BF()
"""

print result

#
# Brainf*ck to AWK compiler, written in AWK by naoya_t/
#
BEGIN {
    inst_buf = ""
    ix = 0
}
{
    gsub(/#.*$/,""); # comment
    gsub(/[^\[\]<>+\-.,]/,""); if (/^$/) next
    inst_buf = inst_buf $0
}
END {
    if (inst_buf ~ /,/) getchar_used = 1

    # compile
    if (optimize >= 1) reset_last()
    output_buf = ""

    indent = ""
    print "BEGIN {"

    indent_incr()
    if (getchar_used) indent_print("read_buf = \"\"")
    if (getchar_used || optimize < 2) indent_print("ix = 0")

    diff_value[">"] = diff_value["+"] = 1
    diff_value["<"] = diff_value["-"] = -1
    incr_decr[">"] = incr_decr["+"] = "++"
    incr_decr["<"] = incr_decr["-"] = "--"

    N = split(inst_buf, ops, "")
    eval(ops,1,N)

    if (optimize >= 1) out_last()
    flush_buf(0)

    indent_decr()
    indent_print("}")

    if (getchar_used) output_getchar_funcs()
}

function eval(ops,begin,end,  i,j,op,s,till)
{
    for (i=begin; i<=end; i++) {
        op = ops[i]
        if (op ~ /[><]/) {
            ix += diff_value[op] # emulation
            if (optimize >= 1) {
                if (last_inst == "ix") {
                    last_arg += diff_value[op]
                } else {
                    out_last()
                    set_last("ix", diff_value[op])
                }
            } else {
                if (getchar_used || optimize < 2) indent_print("ix" incr_decr[op])
            }
        } else if (op ~ /[+-]/) {
            st[ix] += diff_value[op] # emulation
            if (optimize >= 1) {
                if (last_inst ~ /^st\[/) {
                    last_arg += diff_value[op]
                } else {
                    s = set_incr_decr("st[ix]")
                    if (last_inst) out_last()
                    set_last(s, diff_value[op])
                }
            } else {
                if (getchar_used || optimize < 2) indent_print("st[ix]" incr_decr[op])
            }
        } else if (op == ".") {
            s = "printf(\"%c\", st[ix])"
            if (optimize >= 1) {
                s = set_incr_decr(s)
                if (last_inst) out_last()
            }
            if (getchar_used || optimize < 2)
                indent_print(s)
            else
                putchar(st[ix])
        } else if (op == ",") {
            s = "st[ix] = getchar()"
            if (optimize >= 1) {
                s = set_incr_decr(s)
                if (last_inst) out_last()
            }
            indent_print(s)
        } else if (op == "[") {
            nest = 1
            for (j=i+1; j<=N; j++) {
                if (ops[j] == "[") nest++
                if (ops[j] == "]") nest--
                if (nest == 0) { till = j ; break }
            }
            while_loop(ops, i+1, till-1)
            i = till
        } else {
            ;
        }
    }
}
function while_loop(ops,begin,end,  i,j,putchar_used)
{
    putchar_used = 0
    for (j=begin; j<=end; j++) if (ops[j] == ".") { putchar_used = 1; break }

    if (getchar_used || optimize < 2) {
        out_last()
        indent_print("while (st[ix]) {")
        indent_incr()

        eval(ops,begin,end)

        if (optimize >= 1) out_last()
        indent_decr()
        indent_print("}")
    } else {
        while (st[ix]) eval(ops,begin,end)
    }
}

function putchar(ch)
{
    if (ch == 10 || ch == 13) {
        flush_buf(1)
    } else {
        output_buf = output_buf sprintf("%c", st[ix])
    }
}
function flush_buf(cr)
{
    if (output_buf) {
        gsub(/\\/, "\\\\", output_buf)
        if (cr)
            indent_print("print \"" output_buf "\"")
        else
            indent_print("printf(\"%s\", \"" output_buf "\")")
        output_buf = ""
    }
}

function indent_incr()
{
    indent = "  " indent
}
function indent_decr()
{
    indent = substr(indent, 3)
}
function indent_print(line)
{
    print indent line
}
function set_last(inst,arg)
{
    last_inst = inst
    last_arg = arg
}
function reset_last()
{
    last_inst = ""
    last_arg = 0
}
function out_last(  diff)
{
    if (last_inst ~ /ix/) {
        if (last_arg > 1)
            diff = " += " last_arg
        else if (last_arg == 1)
            diff = "++"
        else if (last_arg == 0)
            diff = ""
        else if (last_arg == -1)
            diff = "--"
        else if (last_arg < -1)
            diff = " -= " (0 - last_arg)

        if (diff && (getchar_used || optimize < 2)) indent_print(last_inst diff)
    }
    last_inst = ""
}
function set_incr_decr(s)
{
    if (last_inst == "ix") {
        if (last_arg == 1) { gsub(/ix/, "++ix", s); last_inst = "" }
        else if (last_arg == -1) { gsub(/ix/, "--ix", s); last_inst = "" }
    } else if (last_inst ~ /^st\[/ && s ~ /printf/) {
        if (last_arg == 1) { gsub(/st\[ix\]/, "++" last_inst, s); last_inst = "" }
        else if (last_arg == -1) { gsub(/st\[ix\]/, "--" last_inst, s); last_inst = "" }
    }

    return s
}

function output_getchar_funcs()
{
    print "function getchar(  ch)"
    print "{"
    print "  if (read_buf ~ /^$/) {"
    print "    if (eof) return -1"
#    print "    if ((getline read_buf) < 1) { eof = 1; return -1 }"
    print "    if (getline != 1) { eof = 1; return -1 } ; read_buf = $0" # a2p
    print "  }"
    print "  ch = ord(substr(read_buf,1,1))"
    print "  read_buf = substr(read_buf,2)"
    print "  return ch"
    print "}"
    
    print "function ord(ch, ofs)"
    print "{"
    print "  if (ch == \"\\t\") return 9"
    print "  if (ch == \"\\n\") return 13"
#    print "  ofs = index(\" !\\\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\", ch)"
    print "  if (ch == \"@\") return 64" # a2p
    print "  ofs = index(\" !\\\"#$%&'()*+,-./0123456789:;<=>?.ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\", ch)" # a2p
    print "  return ofs ? 31 + ofs : 0"
    print "}"
}

+       int getContinuousChar(std::istream& is, char c)
+       {
+               int count = 1;
+               char p;
+               while (is >> p) {
+                       if (p != c) break;
+                       count++;
+               }
+               is.unget();
+               return count;
+       }

+#if 0
        case '+': inc(dword [ebp]); break;
        case '-': dec(dword [ebp]); break;
        case '>': add(ebp, 4); break;
        case '<': sub(ebp, 4); break;
#else
       case '+':
       case '-':
               {
                       int count = getContinuousChar(is, c);
                       if (count == 1) {
                               c == '+' ? inc(dword [ebp]) : dec(dword [ebp]);
                       } else {
                               add(dword [ebp], (c == '+' ? count : -count));
                       }
               }
               break;
       case '>':
       case '<':
               {
                       int count = getContinuousChar(is, c);
                       add(ebp, 4 * (c == '>' ? count : -count));
               }
               break;
#endif

import std.stdio;
import std.file;
import std.string;

void main(string[] args){
    string bfCode = cast(string)read(args[1]);
    string[] buf;
    uint ptrIndex;
    uint maxPtrIndex;
    uint indentLevel = 1;

    void addLine(string line){
        buf ~= repeat("\t", indentLevel) ~ line;
    }

    foreach(c; bfCode){
        switch(c){
            case '>':
                addLine("ptr++;");
                if(++ptrIndex > maxPtrIndex){
                    maxPtrIndex++;
                }
                break;
            case '<':
                addLine("ptr--;");
                ptrIndex--;
                break;
            case '+':
                addLine("mem[ptr]++;");
                break;
            case '-':
                addLine("mem[ptr]--;");
                break;
            case '.':
                addLine("putchar(cast(char)mem[ptr]);");
                break;
            case ',':
                addLine("mem[ptr] = cast(ubyte)getchar();");
                break;
            case '[':
                addLine("while(mem[ptr]){");
                indentLevel++;
                break;
            case ']':
                indentLevel--;
                addLine("}");
                break;
            default:
        }
    }
    writefln("import std.c.stdio;");
    writefln("void main(){");
    writefln("\tubyte mem[", maxPtrIndex + 1, "];");
    writefln("\tuint ptr;");
    writefln(buf.join("\n"));
    writefln("}");
}

from __future__ import with_statement
import sys

def brainfuck_compile(source):
    try:
        from cStringIO import StringIO
    except:
        from StringIO import StringIO

    actions = {
        '>': ('pointer += 1', 0),
        '<': ('pointer -= 1', 0),
        '+': ('tape[pointer] = tape.get(pointer, 0) + 1', 0),
        '-': ('tape[pointer] = tape.get(pointer, 0) - 1', 0),
        '.': ('sys.stdout.write(chr(tape.get(pointer, 0)))', 0),
        ',': ('tape[pointer] = sys.stdin.read(1)', 0),
        '[': ('while tape.get(pointer, 0):', 1),
        ']': ('', -1),
    }

    generated = StringIO()
    print >>generated, 'import sys'
    print >>generated, 'tape, pointer = dict(), 0'
    indent = 0
    for c in source:
        if c.isspace(): continue
        stmt, indent_diff = actions[c]
        print >>generated, '%*s%s' % (indent, '', stmt)
        indent += indent_diff

    return generated.getvalue()

def iterchar(fp):
    for line in fp:
        for c in line: yield c

def main(args):
    if args:
        for arg in args:
            with file(arg) as fp:
                code = brainfuck_compile(iterchar(fp))
                print code
    else:
        code = brainfuck_compile(iterchar(sys.stdin))
        print code

if __name__ == '__main__':
    main(sys.argv[1:])

def p_sequence(p):
    "sequence : sequence command"
    p[0] = p[1] + p[2]

def p_sequence_command(p):
    "sequence : command"
    p[0] = p[1]

def p_command_PLUS(p):
    "command : PLUS"
    p[0] = "\nmem[cur] = (mem[cur] + %s) %% 256" % p[1]

def p_command_MINUS(p):
    "command : MINUS"
    p[0] = "\nmem[cur] = (mem[cur] - %s) %% 256" % p[1]

def p_command_LEFT(p):
    "command : LEFT"
    p[0] = "\ncur -= %s" % p[1]

def p_command_RIGHT(p):
    "command : RIGHT"
    p[0] = "\ncur += %s" % p[1]

def p_command_PUT(p):
    "command : PUT"
    p[0] = "\nsys.stdout.write(chr(mem[cur]))"

def p_command_GET(p):
    "command : GET"
    p[0] = "\nmem[cur] = ord(sys.stdin.read(1))"

def p_command_RESET(p):
    "command : RESET"
    p[0] = "\nmem[cur] = 0"

def p_command_loop(p):
    "command : loop"
    p[0] = p[1]
    
def p_loop(p):
    "loop : WHILE sequence WEND"
    p[0] = "\nwhile mem[cur]:%s" % p[2].replace("\n", "\n    ")

def p_error(p): pass

# input and parse
data = sys.stdin.read()
lex.lex()
yacc.yacc()
result = yacc.parse(data)

# output
print """
from collections import defaultdict
import sys
mem = defaultdict(int)
cur = 0
"""

print result

use strict;
use warnings;

sub compile {
    my $source = shift;
    my $out = '';

    my $code = 'sub{no warnings;my(@t, $p, @o);';

    my %patterns = (
        '>' => sub { sprintf '$p+=%d;', length $_[0] },
        '<' => sub { sprintf '$p-=%d;', length $_[0] },
        '+' => sub { sprintf '$t[$p]+=%s;', length $_[0] },
        '-' => sub { sprintf '$t[$p]-=%d;', length $_[0] },
        '.' => sub { sprintf 'push @o,$t[$p];' },
        ',' => sub { sprintf '$t[$p] = shift;' },
        '[' => sub { 'while($t[$p]){' },
        ']' => sub { '}' },
    );
    my $re = qr/>+|<+|\++|-+|\.|,|\[|\]/;

    my $tmp = $source;
    $tmp =~ tr/<>+\-,.[]//cd;
    $tmp =~ s/$re/$patterns{substr($&, 0, 1)}->($&)/ge;

    $code .= $tmp;
    $code .= '@o;}';
}

sub main {
    my $source = do { local $/; <> };
    my $code = compile($source);

    my @out = do { eval $code }->();
    print pack('c*', @out);
}

main;

import java.io.*;
import java.util.*;

public class Sample {
    static final String NL = System.getProperty("line.separator");
    static final String HEADER = "import java.io.*;"+NL+NL+"public class BF {"+NL+
        "    static final int SIZE = 32768;"+NL+"    static byte[] a = new byte[SIZE];"+NL+
        "    public static void main(String[] args) throws IOException {"+NL+
        "\tBufferedReader r = new BufferedReader(new InputStreamReader(System.in));"+NL+
        "\tint ptr = 0;";
    static final String FOOTER = "\tSystem.out.println();"+NL+"    }"+NL+"}";
    static HashMap<Character, String> bfCode = new HashMap<Character, String>();
    static {
        bfCode.put('>', "\tptr++;");
        bfCode.put('<', "\tptr--;");
        bfCode.put('+', "\ta[ptr]++;");
        bfCode.put('-', "\ta[ptr]--;");
        bfCode.put('.', "\tSystem.out.write(a[ptr]);");
        bfCode.put(',', "\ta[ptr] = (byte)r.read();");
        bfCode.put('[', "\twhile (a[ptr] != 0) {");
        bfCode.put(']', "\t}");
    }
    public static void main(String[] args) throws IOException {
        PrintWriter w = new PrintWriter("BF.java");
        w.println(HEADER);
        for (char c : args[0].toCharArray()) {
            String code = bfCode.get(c);
            if (code != null)
                w.println(code);
        }
        w.println(FOOTER);
        w.close();
    }
}

#include <iostream>
#include <fstream>
#include <cctype>
using namespace std;

#define REP(n) for (size_t i = 0; i < n; ++i)

void compile(istream& in, ostream& out)
{
    size_t indent = 0;

#define OUTPUT(s) REP(indent) out << "\t"; out << s << endl;

    OUTPUT("#include <stdio.h>");
    OUTPUT("#include <mem.h>");
    OUTPUT("");
    OUTPUT("int main()");
    OUTPUT("{");
    ++indent;
    OUTPUT("unsigned char buf[33000], *p = buf;");
    OUTPUT("memset(buf, 0, sizeof(buf));");
    OUTPUT("");

    char c;

    while (in.get(c))
    {
        if (isspace(c))
        {
            // pass
        }
        else if (c == '<')
        {
            OUTPUT("--p;");
        }
        else if (c == '>')
        {
            OUTPUT("++p;");
        }
        else if (c == '+')
        {
            OUTPUT("++*p;");
        }
        else if (c == '-')
        {
            OUTPUT("--*p;");
        }
        else if (c == '.')
        {
            OUTPUT("putchar(*p);");
        }
        else if (c == ',')
        {
            OUTPUT("*p = getchar();");
        }
        else if (c == '[')
        {
            OUTPUT("while (*p)");
            OUTPUT("{");
            ++indent;
        }
        else if (c == ']')
        {
            --indent;
            OUTPUT("}");
        }
    }

    --indent;
    OUTPUT("}");

#undef OUTPUT
}

int main(int argc, char* argv[])
{
    if (argc != 2)
    {
        cerr << "usage: name" << endl;

        return -1;
    }

    compile(ifstream(argv[1]), cout);
}

let parse = function
  | '>' -> "stackincr p;"
  | '<' -> "stackdecr p;"
  | '+' -> "incr code.(!p);"
  | '-' -> "decr code.(!p);"
  | '.' -> "print_char (char_of_int !(code.(!p)));"
  | ',' -> "code.(!p) := read_char ();"
  | '[' -> "while 0 <> !(code.(!p)) do"
  | ']' -> "done;;"
  |  _  -> ""  ;;

let main ?(stacksize=256) filename =
  let file = open_in filename in
  Printf.printf "\
    let stackincr x = if %d < (incr x; !x) then x:=0;;\n\
    let stackdecr x = if 0 > (decr x; !x) then x:=%d;;\n\
    let read_char () = int_of_char (read_line () ).[0];;\n\
    let code = Array.init %d (fun i -> ref 0);;\n\
    let p = ref 0;;\n\n"
    (stacksize-1) (stacksize-1) stacksize;
      
  let rec read_loop () =
    try
      let next = input_line file in
      String.iter (fun x -> print_endline (parse x)) next;
      read_loop ();
    with
      End_of_file -> close_in file   
  in read_loop ();;
  

if !(Sys.interactive)=false then
  match (Array.length Sys.argv) with
  | n when n=2 -> main Sys.argv.(1)
  | n when 2<n -> main ~stacksize:(int_of_string Sys.argv.(2)) Sys.argv.(1)
  | n          -> print_endline "usage: ocaml bf2ml.ml [stacksize] filename"
;;

@@ -4,7 +4,7 @@
   | '+' -> "incr code.(!p);"
   | '-' -> "decr code.(!p);"
   | '.' -> "print_char (char_of_int !(code.(!p)));"
-  | ',' -> "code.(!p) := read_char ();"
+  | ',' -> "code.(!p) := input_byte stdin;"
   | '[' -> "while 0 <> !(code.(!p)) do"
   | ']' -> "done;;"
   |  _  -> ""  ;;
@@ -14,7 +14,6 @@
   Printf.printf "\
     let stackincr x = if %d < (incr x; !x) then x:=0;;\n\
     let stackdecr x = if 0 > (decr x; !x) then x:=%d;;\n\
-    let read_char () = int_of_char (read_line () ).[0];;\n\
     let code = Array.init %d (fun i -> ref 0);;\n\
     let p = ref 0;;\n\n"
     (stacksize-1) (stacksize-1) stacksize;

bf <- function(str){
    cat("ptr <- 1", "\n")
    cat("buf <- numeric(1)", "\n")
    for(c in unlist(strsplit(str, ''))){
        switch(c,
            '>' = cat("ptr <- ptr+1; if(is.na(buf[ptr])) buf[ptr] <- 0", "\n"),
            '<' = cat("ptr <- ptr-1; if(is.na(buf[ptr])) buf[ptr] <- 0", "\n"),
            '+' = cat("buf[ptr] <- buf[ptr]+1", "\n"),
            '-' = cat("buf[ptr] <- buf[ptr]-1", "\n"),
            '.' = cat("cat(rawToChar(as.raw(buf[ptr])))", "\n"),
            ',' = cat("buf[ptr] <- as.integer(charToRaw(readLines(n=1)))", "\n"),
            '[' = cat("while(buf[ptr]){", "\n"),
            ']' = cat("}", "\n"))
    }
}

open Camlp4.PreCast

module MyLexer = struct
  module Loc = Loc
  module Token = Token
  module Error = Token.Error

  let mk () loc sc =
    let rec next n = match Stream.peek sc with
      | None   -> Some(EOI, loc)
      | Some x -> let _ = Stream.junk sc in (match x with
        |'>'|'<'|'+'|'-'|'.'|','|'['|']'-> Some((SYMBOL (Printf.sprintf "%c" x)), loc)
        | _                             -> next n)
    in Stream.from next
end

module BF = MakeGram MyLexer

let expr = BF.Entry.mk "expr"
let repr = BF.Entry.mk "repr"
let term = BF.Entry.mk "term"

EXTEND BF
  expr: [[
      t = repr; `EOI     -> <:str_item<
        let p = ref 0 in
        let a = Array.create 1024 0 in
        let inc a p = a.(!p) := a.(!p) + 1 in
        let dec a p = a.(!p) := a.(!p) - 1 in
        let prt a p = print_char (char_of_int a.(!p)) in
        ( $t$ )
      >>
  ]];

  repr: [[
      t = term           -> t
    | t = term; u = repr -> <:expr< $t$; $u$ >>
  ]];

  term: [[
      ">"                -> <:expr< incr  p >>
    | "<"                -> <:expr< decr  p >>
    | "+"                -> <:expr< inc a p >>
    | "-"                -> <:expr< dec a p >>
    | "."                -> <:expr< prt a p >>
    | ","                -> <:expr< a.(!p) := input_byte stdin >>
    | "["; t = repr; "]" -> <:expr< while a.(!p) <> 0 do ( $t$ ) done >>
  ]];
END

let myparse  ?(directive_handler = fun _ -> None) _loc cs = BF.parse expr _loc cs
let myparse2 ?(directive_handler = fun _ -> None) _loc _  = <:sig_item< >>

let _ = Camlp4.Register.register_parser myparse myparse2;

using System;
using System.Collections.Generic;

namespace Kinoko
{
    /*
        BrainF*ck
    */
    class Program
    {
        public static void Main(string[] args)
        {
            LinkedList<int> Tape = new LinkedList<int>();
            Tape.AddLast(0);
            LinkedListNode<int> Head = Tape.First;

            for(int i=0; i < args[0].Length; i++)
            {
                String op = args[0].Substring(i,1);
                switch(op)
                {
                    case "+":
                    {
                        Head.Value++;
                        break;
                    }
                    case "-":
                    {
                        Head.Value--;
                        break;
                    }
                    case "<":
                    {
                        if(Head == Tape.First)
                        {
                            Tape.AddFirst(0);
                        }
                        Head=Head.Previous;
                        break;
                    }
                    case ">":
                    {
                        if(Head == Tape.Last)
                        {
                            Tape.AddLast(0);
                        }
                        Head=Head.Next;
                        break;
                    }
                    case "[":
                    {
                        if(Head.Value == 0)
                        {
                            int nest = 1;
                            int step = 1;
                            while(nest > 0)
                            {
                                if(args[0].Substring(i+step, 1) == "[")
                                {
                                    nest++;
                                }
                                else if(args[0].Substring(i+step, 1) == "]")
                                {
                                    nest--;
                                }
                                step++;
                                if(i+step > args[0].Length)
                                {
                                    break;
                                }
                            }
                            i += step;
                        }
                        break;
                    }
                    case "]":
                    {
                        if(Head.Value != 0)
                        {
                            int nest = 1;
                            int step = 1;
                            while(nest > 0)
                            {
                                if(args[0].Substring(i-step, 1) == "]")
                                {
                                    nest++;
                                }
                                else if(args[0].Substring(i-step, 1) == "[")
                                {
                                    nest--;
                                }
                                step++;
                                if(i-step < 0)
                                {
                                    break;
                                }
                            }
                            i -= step;
                        }
                        break;
                    }
                    case ".":
                    {
                        Console.Write("{0}", ((Char)Head.Value));
                        break;
                    }
                    case ",":
                    {
                        int input = 0;
                        Console.Write("input:");
                        input = Console.Read();
                        Head.Value = input;
                        break;
                    }
                    default:
                    {
                        break;
                    }
                }
            }
        }
    }
}