|# Brainfuck

the brackets are written as { } because of the January syntax.

output is stored in :output: as bits.

the input operator is not implemented.

#|

|| :: control test

|# test programs #|

| :: number 65 test |
    :: start
    :program: (
+ + + + +   + + + + +   + + + + +   + + + + +
+ + + + +   + + + + +   + + + + +   + + + + +
+ + + + +   + + + + +   + + + + +   + + + + +
+ + + + +   [.]
)

| :: overflow test |
    :: start
    :program: (
- - - [.] + + + + + [.]
)

| :: tape test |
    :: start
    :program: (
+ > + + > + + + > > - < < < - - -
< < < + + + + + + +
> > > +
)

| :: control test |
    :: start
    :program: (
+ + + + + { > + > + + < < - }
> [.] > [.]
)

|# interpreter #|

| :: start | :: head empty :: interpret

| :: head empty | :tape: ( 0 0 0 0   0 0 0 0 )

| :symbol: + | :: increment
| :: increment :tape: 0 | :tape: 1 :: restore number
| :: increment? :tape: 1 | :number: 0
| :: increment | :: restore number

| :symbol: - | :: decrement
| :: decrement? :tape: 0 | :number: 1
| :: decrement :tape: 1 | :tape: 0 :: restore number
| :: decrement | :: restore number

| :symbol: > | :: next cell
| :: next cell :after: ; | :tape: ; :: forward
| :: next cell | :tape: ( 0 0 0 0   0 0 0 0 ; )
| :: forward? :after: 0 | :tape: 0
| :: forward? :after: 1 | :tape: 1
| :: forward :after: ;? |
| :: forward |

| :symbol: < | :: previous cell
| :: previous cell? :tape: 0 | :after: 0
| :: previous cell? :tape: 1 | :after: 1
| :: previous cell :tape: ; | :after: ; :: head not empty
| :: previous cell | :after: ; :: refill head
| :: head not empty :tape: $x? |
| :: head not empty | :: refill head
| :: refill head | :tape: ( 0 0 0 0   0 0 0 0 )

| :: booleanise? :tape: 0 | :number: 0
| :: booleanise :tape: 1? | :boolean: true :: restore number
| :: booleanise | :boolean: false :: restore number

| :symbol: { | :: booleanise :: forward jump
| :: forward jump :boolean: true |
| :: forward jump :boolean: false | :: skip forward
| :: skip forward? :program: { | :seen: { :: skip forward
| :: skip forward :program: } | :seen: }
| :: skip forward? :program: $other | :seen: $other
| :: skip forward | :: abort :reason: bracket mismatch

| :symbol: } | :: booleanise :: backward jump
| :: backward jump :boolean: true :seen: } | :program: } :: rewind
| :: backward jump :boolean: false |
| :: rewind? :seen: } | :program: } :: rewind
| :: rewind :seen: {? |
| :: rewind? :seen: $other | :program: $other
| :: rewind | :: abort :reason: bracket mismatch

| :symbol: [.] | :: output
| :: output? :tape: 0 | :output: 0 :number: 0
| :: output? :tape: 1 | :output: 1 :number: 1
| :: output | :output: ; :: restore number

| :symbol: , | :: abort :reason: no input facility

| :symbol: $other |

| :: restore number? :number: $digit | :tape: $digit
| :: restore number |

| :: interpret? :program: $symbol | :symbol: $symbol :seen: $symbol
| :: interpret | :: done