Bologna is an esoteric interpreted programming language

• Intended to be minimalistic yet (somewhat?) useable, Bologna is an un-intuitive, ridiculous language.

• Bologna is a superset of the BrainFuck programming language, and therefore retains the original 8 tokens from BrainFuck (+-<>[],.)

About Bologna

The name "Bologna" was chosen because this language is similar to the food;

That is, somewhat gross, and probably not your first choice.

• Bologna was made to see what could be acheived with a very simple language.

Basics

• No conventional variables. All values are stored at some index in the 30,000 signed 8-bit integer array
• No functions
• No data types, as everything is stored as an unsigned 8 bit integer
• Interpreted directly from your file at runtime
• So dumb its cool

Using Bologna:

1. Download the latest Bologna release here
2. In the same directory where you downloaded Bologna, run

bash bologna.bash my_bologna_file.bf

Cheat Sheet

Pointer Manipulation
>x	Shift pointer right x times
<x	Shift pointer left x times
:x	Move pointer to memory index x
Numerical Operations
_	Set the byte at the pointer to zero
+x	Add x to the byte at the pointer value
-x	Subtract x from the byte at the pointer
*x	Multiplty the byte at the pointer by x
/x	Integer division of the byte at the pointer by x
Input / Output
,	Takes a character input and stores it in the byte at the pointer
.	Prints the character at the byte at the pointer
Loops
[	If the byte at the pointer is zero, jump past matching ]
]	If the byte at the pointer is non-zero, jump back to command after matching [
{ }x	Repeat code inside the braces x times
Memory Indexing
#	Get the value of the pointer's byte
#x	Get value of the byte at index x
Query Operator
?(x<y){}	If the (boolean statement) is true, run the code inside the {} braces
Logical Operators	Note: Can only be used inside of the '( )' of a Query
>	Greater than
<	Less than
=	Equal to
!	Not equal to
Other Operators
~	End program execution
"comments"	Comment (By default text is ignored, but comments ignore commands) Ex: "+-.<>" will not execute any of the operators)

Command Explanations

POINTER MANIPULATION

Initially, the program pointer points to the beginning of the memory array at index 0.

Left Shift

<x Shifts the pointer to the left x number of times.

Right Shift

>x Shifts the pointer to the right x number of times

Absolute Shift

:x Shifts the pointer to memory index x, regardless of its current position.

Input / Output

Input

, Takes a single character input through stdin and stores it in the byte at the pointer

Output

.x Prints the character at the pointer's byte x times.

Special Case

#x. Prints out the character value of the byte at memory index x.

• See memory indexing for more information on this topic.

Numerical Operations

Zero

_ Sets the value of the current pointer to zero

Multiplication

*x Multiplies current pointer value by x

Division

/x Divides the current pointer value by x. Note that all division is integer division.

LOOPS

"While" Loop

[ ] BrainFuck's original loop implementation.

For Loop

{ }x Repeats code inside the indices x times, or { }#5 repeats as many times as the value at memory index 5. Note that nested loops are not yet supported.

MEMORY INDEXING

Current Byte Operator

# Gets value of current pointer (will be treated as if an integer was in the code) {}# A for loop that repeats as many times as the value of the current pointer +# Adds current pointer value to the current pointer value

Byte at Index Operator

#x Every case from above applies, but rather than referencing the current pointer, it references pointer at memory index x

Memory is an array of signed 8-bit integers
-------------------------------------------
#x Represents the value at memory index x

EX: #1 = mem[1] = some_value
-------------------------------------------


>#1 (Move pointer right #1 times)

<#15 (Move pointer left #15 times)

+#4 (Add #4 to the current pointer)

-#6 (Subtract #6 from the current pointer)

.#91 (Print current pointer #91 times)

#12. (Print the value of #12)

:#7 (Move pointer to index matching the value at memory index 7)

*#2 (Multiply current pointer value by #2)

/#8 (Divide current pointer value by #8)

{}#3 (For loop repeats #3 times)

QUERY OPERATOR

Query

?(){} The query operator evaluates the expression inside of the parentheses, and only executes the code inside of the braces if the expression evaluates to true.

• Note that whitespace inside of '()' or between '?, (), {}' is not allowed.
• Example: ?(a < b){+} is not permitted due to whitespace inside the logical expression
• ? (a<b) {+} is also not permitted due to whitespace between the ? ( and ) {

CODE
====================================

"Set mem[0] to 65 (ASCII A)"
:0 +65

"Set mem[1] to 10"
:1 +10

"Set mem[2] to 10"
:2 +10


"If ('10'='10')then{.}"
?(#1=#2){.}

EXPECTED OUTPUT
====================================
A

Logical operators

• < Less than operator
• > Greater than operator
• = Equal to operator
• ! Not equal operator

?(10<11){+} "This is true, the '+' will be executed"

?(10>11){+} "This is false, the '+' will not be executed"

?(10=11){+} "This is false, the '+' will not be executed"

?(10!11){+} "This is true, the '+' will be executed"

OTHER OPERATORS

Exit

~ Terminates program execution immediately.

Comments

" " Ignores commands inside of quotes.

• By default, characters which are not operators are already ignored
• Comments allow usage of operator characters without execution

"Add 6 to memory index 10 with :10 +6" <- The operators here will not be executed
10: +6                                 <- The operators here will be executed

TODO

• Add Nested for loop support { { }y }x (They currently dont work at all...)
• Fix while loop [ ] bug - currently, while loops will fail to exit under certain conditions.

Bologna Examples

Hello World Example

hello_world.bf

+72._+69._+76._+76._+79._+32._+87._+79._+82._+76._+68._+10.

"EXPECTED OUTPUT:
==========================================================="
HELLO WORLD

Counter Example

An example of a for loop that counts from 0 to 9

counter_example.bf

"Go to memory index 3, then add 10"
:3 +10

"Go to memory index 0, then add 48 (ASCII '0' character)"
:0 +48

"Print value and increment byte by one. Repeat '#3' times, which evaluates to 10 repitions."
{.+}#3

"Zero the index, add 10 (ASCII linebreak), and print it out"
_ +10 .

"Expected Output:
========================================================================================="
0123456789

Tic Tac Toe

(Unfinished) Tic Tac Toe example written in Bologna

tic_tac_toe.bf

FULL TIC TAC TOE AVAILABLE IN /bologna_files


"EXAMPLE (PORTION) OF CODE: 
===================================================================================="

"Print: Pick a cell 1 - 9) "

+80. _ +105. _ +99. _ +107. _ +32. _ +97. _ +32. _ +67. _ +101. _
+108. _ +108. _ +32. _ +49. _ +32. _ +45. _ +32. _ +57. _ +41. _ #11.

"Take a character input and store in memory index 50"
:50 _ ,

"Move to the index of the character the user specified. Write an 'O' in the cell"
:#50 _ +#13 :0 #10.


"EXAMPLE OUPUT:
===================================================================================="
-------
|X|O|X|
-------
|O|5|6|
-------
|7|8|9|
-------


Player 1 - Pick a Cell 1 - 9) 5


-------
|X|O|X|
-------
|O|X|6|
-------
|7|8|9|
-------