NAME

       beef - Flexible Brainfuck interpreter

SYNOPSIS

       beef [OPTION]... FILE

DESCRIPTION

       Beef is a flexible interpreter for the Brainfuck programming language.

       It  can  be  configured  using  the  options  described  below,  making it possible to run
       Brainfuck programs that make assumptions about the behavior of the interpreter.

       Beef sets no arbitrary limit to the size of the memory  tape  used  by  the  program,  and
       allocates memory cells as they are needed.

OPTIONS

       -p, --program=PROGRAM
          Execute PROGRAM. This can only be used if a FILE containing a Brainfuck program has not
          been provided on the command line after all options.

       -s, --store=WHAT
          Choose the value to store in the tape when the end of input is reached.  WHAT  defaults
          to  zero  (store  a  zero);  other possible values are eof (store -1, the value usually
          assigned to the C constant EOF) or same (leave the value untouched).

       -d, --enable-debugging
          Enable debugging support. By default, debugging instructions are not executed.

       -o, --output-file=FILE
          Write program's output to FILE.

       -i, --input-file=FILE
          Read program's input from FILE.

       FILE can be local path or any URI supported by GIO. If FILE  is  '-',  standard  input  or
       standard output, depending on the context, will be used.

BRAINFUCK LANGUAGE

       Brainfuck  programs  work  on a memory tape which contains a virtually unlimited number of
       cells; each cell can store a value, which can be seen either  as  a  character  or  as  an
       integer  number  (its ASCII encoding) depending on the context. There is a cursor pointing
       to one of the cells, which is considered to be the current one; the cursor  can  be  moved
       around at will.

       A Brainfuck source file is made of a number of Brainfuck instructions; any symbol which is
       not an instruction is considered a comment and is ignored.  There are exceptions  to  this
       rule, see below.

       The Brainfuck instructions are:

       +
          Increase the value in the current cell by one.

       -
          Decrease the value in the current cell by one.

       >
          Move the cursor one cell to the right.

       <
          Move the cursor one cell to the left.

       [
          Start  a loop. The instructions contained in the loop are executed as long as the value
          of the current cell is not zero.

       ]
          End a loop started by a '[' instruction.

       ,
          Read a character from the input and store it in che current cell.

       .
          Write the value of the current cell to the output.

       #
          Dump the content of the memory tape for debugging purposes. This instruction is ignored
          unless the enable-debugging option is present.

       If  the  first  line of the source file starts with the magic sequence '#!' it is ignored.
       This allows you to execute a Brainfuck program without calling Beef explicitly,  like  you
       would do for eg. a Python program.

       The symbol '!' has a special meaning to Beef: it marks the end of a program's code and the
       beginning of its input. If this symbol is present in the source file, runtime  input  will
       be ignored.

EXAMPLES

       The classic Hello World program could be written in Brainfuck as

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

       The following Brainfuck program can be used to replace the cat(1) utility:

          #!/usr/bin/beef
          ,[.,]

       That's  of  course  assuming you don't need any of cat(1)'s fancy commandline options, you
       have a shell with working I/O redirection and a sense of humor.