1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
% BEEF(1) Beef @VERSION@
% Andrea Bolognani <eof@kiyuko.org>
% October 2014
# 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
`-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.
|
