Control.Monad.BrainFuck

Documentation

newtype BrainFuck a

Constructors

BrainFuck (DataPointer -> ([Char], DataPointer, a))

Instances

Monad BrainFuck

Defined in Control.Monad.BrainFuck

Methods

(>>=) :: BrainFuck a -> (a -> BrainFuck b) -> BrainFuck b

(>>) :: BrainFuck a -> BrainFuck b -> BrainFuck b

return :: a -> BrainFuck a

fail :: String -> BrainFuck a

Functor BrainFuck

Defined in Control.Monad.BrainFuck

Methods

fmap :: (a -> b) -> BrainFuck a -> BrainFuck b

(<$) :: a -> BrainFuck b -> BrainFuck a

Applicative BrainFuck

Defined in Control.Monad.BrainFuck

Methods

pure :: a -> BrainFuck a

(<*>) :: BrainFuck (a -> b) -> BrainFuck a -> BrainFuck b

liftA2 :: (a -> b -> c) -> BrainFuck a -> BrainFuck b -> BrainFuck c

(*>) :: BrainFuck a -> BrainFuck b -> BrainFuck b

(<*) :: BrainFuck a -> BrainFuck b -> BrainFuck a

type DataPointer = Integer

func :: BrainFuck f -> DataPointer -> ([Char], DataPointer, f)

Retrieve the inner function

brainfuck :: BrainFuck f -> String

Evaluate the monad and get a brainfuck program

next :: BrainFuck ()

move data pointer right

prev :: BrainFuck ()

move data pointer left

incr :: BrainFuck ()

increment data

decr :: BrainFuck ()

decrement data

output :: BrainFuck ()

output byte at data pointer

input :: BrainFuck ()

input byte, storing at data pointer

open :: BrainFuck ()

if byte at data pointer is zero, jump to opcode after close

close :: BrainFuck ()

if byte at data pointer is nonzero, jump to optoce after matching open

debug :: BrainFuck ()

ignored if brainfuck machine does not support debugging

opcode :: Char -> BrainFuck ()

Adds an arbitrary character to the program. Should not be used directly.

opcode' :: (DataPointer -> DataPointer) -> Char -> BrainFuck ()

Adds an arbitrary character to the program, and updates the data pointer. Should not be used directly.

loopUnless0 :: BrainFuck a -> BrainFuck a

The loop is only run if the data pointer doesn't point to 0.

On entry, the loop body is run, and then it loops, until the address the data pointer originally pointed at has a value of 0.

Any change that the loop body makes to the address of the data pointer is reset each time through the loop (and at the end). This is necessary to keep the BrainFuck monad's DataPointer consistent no matter what happens when running the loop.

addr :: BrainFuck DataPointer

Gets the current address of the data pointer.

setAddr :: Integer -> BrainFuck ()

Moves the data pointer to a specific address.

withAddr :: Integer -> BrainFuck a -> BrainFuck a

Runs an action with the data pointer temporarily set to an address, then restores the data pointer.

multi :: BrainFuck () -> Int -> BrainFuck ()

Run an action multiple times.

add :: Word8 -> BrainFuck ()

sub :: Word8 -> BrainFuck ()

zero :: BrainFuck ()

Zeros the current data cell.

set :: Word8 -> BrainFuck ()

Changes the current data cell to contain a specific value. (It can start at any value).

alloc :: BrainFuck a -> BrainFuck a

For higher-level programming in brainfuck, it's useful to have a way to run a function, while allocating a memory cell, which is initialized to contain 0.

This and many of the functions below assume that cells to the left are in use, while cells to the right are unused and may contain any data. Higher-level functions should generally avoid changing the current cell, and should instead alloc a new one to use.

alloc' :: (DataPointer -> BrainFuck a) -> BrainFuck a

withChar :: Char -> BrainFuck a -> BrainFuck a

Allocates a new memory cell, populates it with a Char, and runs the action.

loopFrom :: Word8 -> (DataPointer -> BrainFuck ()) -> BrainFuck ()

Allocates a cell and uses it as the loop counter, starting from the provided value. The action will continue running in a loop until it decrements the counter to 0.

forever :: BrainFuck a -> BrainFuck ()

Runs an action in an infinite loop. The action can modify its current memory cell, or allocate and use new ones, and will not exit the loop.

copy :: DataPointer -> DataPointer -> BrainFuck ()

Copies the value of a cell.

withNot :: DataPointer -> BrainFuck () -> BrainFuck ()

Runs the action with a new cell that is logically NOT the value of the passed pointer.

unless0 :: DataPointer -> BrainFuck () -> BrainFuck ()

Runs the action unless the data pointer points to 0.

when0 :: DataPointer -> BrainFuck () -> BrainFuck ()

Runs the action when the data pointer points to 0.

if0 :: DataPointer -> (BrainFuck (), BrainFuck ()) -> BrainFuck ()

Monadic if; the first action is run if the data pointer points to 0, else the second action is run.

sumNext :: BrainFuck ()

Adds the current and next data cells. The next cell is zeroed and the sum is left in the current cell.

mult :: Word8 -> BrainFuck ()

Multiplies the current data cell by some value. Uses and zeros some of the following cells.

display :: String -> BrainFuck ()

Displays a string. Tries to generate a fairly small brainfuck program, using a few encoding tricks. The current cell is modified, and not cleaned up at the end, so run using alloc if necessary.

demo :: String

Prints out the alphabet, repeatedly, with some whitespace fun to make it more interesting.

demo' :: BrainFuck ()

cat :: String

Copy input to output.

helloworld :: String

Simple hello world.

helloworld' :: String

Optimized to use less space.

optimize :: String -> String

Simple optimiser for brainfuck code.

compile :: FilePath -> BrainFuck () -> IO ()

Uses the MOVfuscator v1 to build a Linux executable from a BrainFuck monad action. The executable is implemented entirely using the MOV instruction. It may be a little slow, especially when loops are involved.

Prereq: Clone https://github.com/xoreaxeaxeax/movfuscator, build the v1 brainfuck to MOV compiler (in the poc/) directory, and put it in PATH. Also apt-get install nasm.

type ASM = String

movfuscate :: BrainFuck () -> IO ASM

nasm :: FilePath -> ASM -> IO FilePath

ld :: FilePath -> FilePath -> IO ()