Execute Brain****: Difference between revisions

 

=={{header|11l}}==

V tape = DefaultDict[Int, Int]()

V cell = 0

ptr++

 

 

=={{header|68000 Assembly}}==

Takes a Brainfuck program as a command line parameter. Escape character (escape key!) is handled as a 0 when inputting characters. Does NOT support break, so programs that don't end by themselves will run forever.

; Brainfuck interpreter by Thorham

;

ds.b 1024*64

tapeEnd

 

=={{header|8080 Assembly}}==

Contractions and clear loops are optimized. It expects to run under CP/M.

 

getch: equ 1 ; Read character from console

putch: equ 2 ; Print character to console

;;; fall through into it.

nop ; No-op (sentinel value)

 

{{out}}

circular 64k-cell tape with 8-bit cells.

 

cpu 8086

putch: equ 2h ; Print character

ibuf: resb 256 ; 255 char input buffer

stack: resw 512 ; 512 words for the stack

 

{{out}}

=={{header|Agena}}==

Tested with Agena 2.9.5 Win32

 

# execute the Brain**** program in the code string

bf( code )

until code = ""

 

=={{header|ALGOL 68}}==

 

[[/ALGOL 68|Implementation in Algol 68]].

 

=={{header|AppleScript}}==

Outputs debug in a .txt file similar to that of [http://brainfuck.tk brainfuck.tk]

set codeString to text returned of (display dialog "Enter BF code:" buttons "OK" default answer "")

set inputString to text returned of (display dialog "Enter input string" buttons "OK" default answer "")

display dialog strout

close access debug

 

=={{header|Arturo}}==

 

instrPointer: instrPointer+1

jumphash

 

 

 

 

 

{{in}}

 

 

{{out}}

=={{header|AutoIt}}==

 

; A AutoIt Brainfuck Interpreter

; by minx

If $Open>0 Then Return SetError(2,0,$i)

Return 0

 

=={{header|AWK}}==

Expects the program (not the program file) to be the first argument to the script. Cells don't wrap (trivial if desired) and the code and arena are unbounded.

 

bf=ARGV[1]; ARGV[1] = ""

compile(bf)

}

}

 

{{out}}

Note that this implementation has no error checking.

 

r₁→P

r₂→I

End

r₁

 

'''Example'''

 

'''Output'''

 

==={{header|Applesoft BASIC}}===

1 P = P + T : ON P < E GOTO 11 : O = 1E99

2 P = P - T : ON P > M GOTO 11 : O = 1E99

95 C$ = "++++++++[>++++[>++>+++>+++>+<<<<-]>+>->+>>+[<]<-]>>.>>---.+++++++..+++.>.<<-.>.+++.------.--------.>+.>++.+++."

98 L = LEN(C$)

 

==={{header|BaCon}}===

By the author of BaCon, Peter van Eerten.

REM Brainfuck interpreter

 

 

INCR cursor

 

\ ">---.+++++++..+++.>.<<-.>.+++.------.--------.>+.>++.+++."

PROCbrainfuck(bf$)

NEXT

ENDPROC

{{out}}

<pre>Hello World!</pre>

 

=={{header|Brainf***}}==

The BF interpreter in BF (when filtered through a comment remover) looks like:"

 

>>>,[->+>+<<]>>[-<<+>>]>++++[<++++++++>-]<+<[->>+>>+<<<<]>>>>[-<<<<+>>

>>]<<<[->>+>+<<<]>>>[-<<<+>>>]<<[>[->+<]<[-]]>[-]>[[-]<<<<->-<[->>+>>+

-<<<+>>>[<<<->>>[-]]]]]]]]]]<<<[<+>[-]]<]>[-]]<<[->>>>>+<<<<<]>>>>>+>[

-]]>>]

 

NYYRIKKI:

No more explaining... here is the code:"

 

>>>+[,>+++++++[<------>-]<[->+>+<<]>>[-<<+>>]<->+<[>-<[-]]>[-<<[-]++++

+>>>>>]<<[->+>+<<]>>[-<<+>>]<-->+<[>-<[-]]>[-<<[-]++++++++>>>>>]<<[->+

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

]>>[-[->>+<<]+>>]+>,<[-<<]<<<<<[<<<]>>]<<++++++++>>>]

 

Daniel B. Cristofani

 

 

>>>+[[-]>>[-]++>+>+++++++[<++++>>++<-]++>>+>+>+++++[>++>++++++<<-]+>>>,<++[[>[

http://www.hevanet.com/cristofd/brainfuck/]

 

 

Links:

=={{header|Burlesque}}==

 

".""X"r~"-""\/^^{vvvv}c!!!-.256.%{vvvv}c!sa\/"r~"+""\/^^{vvvv}c!!!+.

256.%{vvvv}c!sa\/"r~"[""{"r~"]""}{\/^^{vvvv}c!!!}w!"r~">""+."r~"<""

-."r~"X""\/^^{vvvv}c!!!L[+]\/+]\/+]^^3\/.+1RAp^\/+]\/[-1RA^^-]\/[-\/

"r~"\'\'1 128r@{vv0}m[0"\/.+pse!vvvv<-sh

 

However, this implementation does not support input.

 

=={{header|Clojure}}==

 

(def ^:dynamic *input*)

(println *output*)

(println (apply str (map char *output*)))))

{:ptr 4, :cells {4 10, 3 33, 2 100, 1 87, 0 0}}

[72 101 108 108 111 32 87 111 114 108 100 33 10]

 

nil

 

The alternate implementation at [[Execute Brain****/Clojure]] showcases a rather different approach.

 

=={{header|COBOL}}==

This interpreter takes a command line argument with the path to a Brain**** program. It uses strings as storage, so storage is unbounded on both sides of the pointer, but behavior is undefined for cell values lower than zero or higher than 0x10ffff.

 

pointer_numeric = 1/0

tape_behind = ''

in_buffer = stdin

cdr = in_buffer

 

=={{header|Common Lisp}}==

{{Trans|Pascal}}

Fix of [[#Pascal]] to run in Delphi.

program Execute_Brain;

 

// Print text "press ESC to continue....." and wait for ESC to be pressed

ExecuteBF(pressESCtoCont + waitForEsc);

 

=={{header|dodo0}}==

 

clojure('count', 1) -> size

clojure('nth', 2) -> charAt

#Execute the program instructions

program(buffer, input) -> buffer, input

Execution:

<pre>

=={{header|E}}==

[[/E|Implementation in E]].

 

=={{header|Elena}}==

Factor comes with a Brainf*** interpreter. See the implementation [https://github.com/factor/factor/blob/master/extra/brainfuck/brainfuck.factor here].

{{works with|Factor|0.99 2020-07-03}}

 

{{out}}

<pre>

The source employs F90 so as to gain the convenience of a service routine SEEK contained within RUN that thereby has access to the PROG and the instruction pointer - though these could have been passed as additional parameters. The main idea is that the expression can fit on one line and special code is not used for the two cases. The STORE array of cells is represented as an array of CHARACTER*1 variables rather than a CHARACTER*n single variable. This means that an element is addressed as STORE(i), rather than STORE(i:i), and that STORE = CHAR(0) initialises the whole array to zero. If it were CHARACTER*n, then only the first character would be zero, all subsequent would be blanks. It is not clear what size a cell represents, but a single character suffices for the trial run. For usage that involves arithmetic, the ICHAR and CHAR functions are needed which work on values of 0:255. The cell array could be declared INTEGER*1 instead, which would allow arithmetic without sacrifices on the altar of type checking. Such a variable in two's complement has values of -128:127 however with only addition and subtraction supported this doesn't matter - the bit patterns are the same as for unsigned integers. Larger integer sizes are possible if required, but would require changes to the READ and WRITE statements because A1 format works at the high-order end of a multi-byte variable.

 

INTEGER MSG,KBD

CONTAINS !A twisted interpreter.

CALL RUN(HELLOWORLD,STORE) !Have a go.

 

Output:

<pre>

Since the increment and decrement instructions are often repeated, it is simple enough to scan ahead and count up the repetitions via a function (that also manipulates its environment), and convert a sequence of operations into a single operation. Thus, this is an ''optimising'' Brain*uck compiler!

 

Converts the Brain*uck in PROG into the equivalent furrytran source...

CHARACTER*(*) PROG !The Brain*uck source.

OPEN (F,FILE="BrainFort.for",STATUS="REPLACE",ACTION="WRITE")

CALL BRAINFORT(HELLOWORLD,30000,KBD,MSG,F)

Code: ++++++++[>++++[>++>+++>+++>+<<<<-] >+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.

CHARACTER*1 STORE(30000)

STORE(D) = CHAR(ICHAR(STORE(D)) + 2)

WRITE (6,'(A1,$)') STORE(D)

Which, when compiled and run, produces...

<pre>

Hello World!

</pre>

 

=={{header|Furor}}==

argc 3 < { ."Usage: furor brainfuck.upu brainfuckpgmfile\n" }{

2 argv getfile // dup #s print free

// + - < > [ ] . ,

§_2b_ §_2d_ §_3c_ §_3e_ §_5b_ §_5d_ §_2e_ §_2c_

 

Yet another solution:

 

###sysinclude stringextra.uh

argc 3 < { ."Usage: furor brainfuck.upu brainfuckpgmfile\n" }{

/* 0f */ §____ §____ §____ §____ §____ §____ §____ §____ §____ §____ §____ §____ §____ §____ §____ §____

 

 

=={{header|GAP}}==

Brainfuck := function(prog)

local pointer, stack, leftcells, rightcells, instr, stackptr, len,

# 3

# 5

 

=={{header|Go}}==

Fixed size data store, no bounds checking.

 

import "fmt"

}

}

{{out}}

<pre>

=={{header|Groovy}}==

 

 

def program = '', memory = [:]

throw new IllegalStateException('Could not find matching start bracket')

}

Testing:

{{out}}

<pre>Hello World!</pre>

 

=={{header|Haskell}}==

[[/Java|Implementation in Java]].

 

 

public class Interpreter {

interpreter.execute(">++++++++[-<+++++++++>]<.>>+>-[+]++>++>+++[>[->+++<<+++>]<<]>-----.>->+++..+++.>-.<<+[>[+>+]>>]<--------------.>>.+++.------.--------.>+.>+.");

}

 

=={{header|JavaScript}}==

Part of the Jsi source kit unit tests. bf code from Hello World/text task entry.

 

* javascript bf interpreter

* by wenxichang@163.com

++>++++++++++++<<<<<<<<<-]>>>>+.>>>>+..<.<++++++++.>>>+.<<+.<<<<++++.<+

+.>>>+++++++.>>>.+++.<+++++++.--------.<<<<<+.<+++.---.

 

{{out}}

{{trans|Python}}

 

 

function execute(src)

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

>+++++++.<<<[[-]<[-]>]<+++++++++++++++.>>.+++.------.--------.>>+.>++++."""

 

{{out}}

=={{header|Kotlin}}==

{{trans|Groovy}}

 

class Brainf__k(val prog: String, memSize: Int) {

val prog = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>."

Brainf__k(prog, 10).execute()

 

{{out}}

Expects the program to be the first argument, compiles to bytecode (without optimization), uses a 1MB array of cells (and wraps), includes some rudimentary compiler diagnostics.

 

 

include "sys.m"; sys: Sys;

}

}

 

{{out}}

===Simple meta-implementation using <code>load</code>===

 

['>'] = 'ptr = ptr + 1; ',

['<'] = 'ptr = ptr - 1; ',

end

 

 

BTW very fast, considering how simple it is.

 

=={{header|M2000 Interpreter}}==

Module Checkit {

\\ Brain**** Compiler

}

Checkit

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

Module[{p = Characters[program], pp = 0, m, mp = 0, bc = 0,

instr = StringToStream[input]},

While[bc < 0, pp--; Switch[p[[pp]], "[", bc++, "]", bc--]]]]];

Close[instr];];

 

Example:

 

 

{{out}}

 

=={{header|Nanoquery}}==

// so we have to implement our own

def get_char()

 

loc += 1

 

=={{header|Never}}==

record BFI

{

0

}

 

=={{header|Nim}}==

 

var

inc i

 

 

{{out}}

 

=={{header|Objeck}}==

@program : String; @mem : Int[];

@ip : Int; @dp : Int;

return 0;

}

 

=={{header|OCaml}}==

 

=={{header|Ol}}==

(define (bf program stack-length)

(program-counter 0)

(stack-pointer 0))

(let ((ch (string-ref program pc))

(pc (+ pc 1)))

(case ch

(else

(let ((ch (string-ref program pc))

(pc (+ pc 1)))

(case ch

 

 

=={{header|PARI/GP}}==

A case statement would have been really useful here...

prog=Vec(Str(prog));

my(codeptr,ptr=1,v=vector(1000),t);

)

)

 

=={{header|Pascal}}==

program rcExceuteBrainF;

 

end.

 

 

=={{header|Perl}}==

[[/Perl|Implementation in Perl]].

 

 

 

 

{{out}}

<pre>

 

=={{header|PHP}}==

function brainfuck_interpret(&$s, &$_s, &$d, &$_d, &$i, &$_i, &$o) {

do {

$inp = '123';

print brainfuck( $code, $inp );

 

=={{header|PicoLisp}}==

of a single cell initially, and grows automatically in both directions. The

value in each cell is unlimited.

 

(de compile (File)

(while (cadr Data) # Find beginning of data

(setq Data @) )

{{out}}

<pre>: (compile "hello.bf")

===Dynamic solution===

Dynamic and unlimited. Unwraping cells. Checking syntax.

(let S NIL

(make

-----.[-]>++++++++[<++++>- ]<+.[-]++++++++++." ) )

 

=={{header|Pointless}}==

 

-- https://github.com/allisio/pointless/blob/master/lib/examples/brainfuck.ptls

 

op = ops[vm.ip]

byte = vm.data[vm.dp]

 

=={{header|Potion}}==

{{incorrect|Potion|

Tape is infinite length to the right. Cells use default Potion integer type.

bf = (code) :

tape = (0)

.

.

 

=={{header|Prolog}}==

Features: Ignores comments (non brainf*** characters), Can run as command, or from file, no limit on memory.

 

Starting point, call with program in atom.

*******************************************/

% The next instruction, and remaining code

next_instruction([_], [], []).

{{out}}

<pre>

true

</pre>

 

=={{header|Python}}==

 

[[/Python|Implementation in Python]].

 

=={{header|Racket}}==

As an appetizer this runs in Racket as is:

 

#lang planet dyoo/bf

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

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

>>.+++.------.--------.>>+.

 

=={{header|Raku}}==

=={{header|Rebol}}==

Works with Rebol3

REBOL [Title: "Brainfuck interpreter"]

 

bf/init input

bf/run

 

=={{header|REXX}}==

The REXX code is original, but the BRAINF░CK program was modified from the example given in Wikipedia: &nbsp; [http://en.wikipedia.org/wiki/Brainfuck]

@.=0 /*initialize the infinite "tape". */

p =0 /*the "tape" cell pointer. */

if ?=='[' then do; c=c-1; if c==0 then return k+1; end

end /*k*/

'''output''' &nbsp; when using the default program as input:

<pre>

Hello World!

</pre>

 

=={{header|Rust}}==

 

use std::env;

use std::fs::File;

pc += 1;

}

 

=={{header|Scala}}==

import scala.annotation._

 

}

}

 

=={{header|Scheme}}==

 

=={{header|Seed7}}==

 

const proc: brainF (in string: source, inout file: input, inout file: output) is func

begin

brainF("++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.");

 

{{out}}

 

Original source [http://seed7.sourceforge.net/algorith/puzzles.htm#brainf7].

 

=={{header|Sidef}}==

{{trans|Perl}}

define eof_val = -1;

define unbalanced_exit_code = 1;

commands{code[cmd]}.run;

cmd++;

 

=={{header|Standard ML}}==

=={{header|Swift}}==

 

 

let valids = [">", "<", "+", "-", ".", ",", "[", "]"] as Set<Character>

while ip != numChars {

tick()

 

=={{header|Tcl}}==

[[/Tcl|Implementation in Tcl]].

 

 

=={{header|UNIX Shell}}==

{{works with|Bourne Again SHell}}

# BrainF*** interpreter in bash

if (( ! $# )); then

,) read -n1 c; memory[mp]=$(LC_CTYPE=C printf '%d' "'$c");;

esac

 

Sample run:

=={{header|VBScript}}==

{{trans|PHP}}

'VBScript Implementation

 

">+++++++.<<<[[-]<[-]>]<+++++++++++++++.>>.+++.------.--------.>>+.>++++."

inpstr = ""

{{Out}}

<pre>C:\>cscript /nologo brainf.vbs

 

C:\></pre>

 

=={{header|Wren}}==

{{trans|Kotlin}}

 

class Brainf__k {

 

var prog = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>."

 

{{out}}

 

[[/x86_Assembly|Implementation in x86]]

 

=={{header|zkl}}==

const CELLS=0d30_000;

if(Void==pgm.span("[","]")){ println("Mismatched brackets"); return(); }

} // while

}catch(IndexError){} // read past end of tape == end of program

bf("++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++.."

"+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.");

 

// rot13

{{out}}

<pre>

http://www.hevanet.com/cristofd/brainfuck/]

</pre>