Make your own free website on Tripod.com
 Search: Lycos Tripod     Dating Search
  share this page Share This Page  report abuse Report Abuse  build a page Edit your Site  show site directory Browse Sites  hosted by tripod
    « Previous | Top 100 | Next » hosted by tripod

BACK: BRAINFUCK - PART 1
NEXT: BRAINFUCK - PART 3
BrainFuck - Part 2

More Complicated Programs
    As previously mentioned, Brainfuck is Turring-Complete and is capable of performing any task that a normal computer could do. To see how some common functions can be done in Brainfuck, consider the following program fragment from a typical programming language:

a=10;

    In the example, the value 10 is assigned to a variable called a. This is probably one of the simplest operations that can be performed using a typical programming language, however it is a bit more complicated when using Brainfuck. The first thing to realize is that the previous example can be implemented in Brainfuck in several different ways, where some are more efficient than others. For simplicity, we will use the following method to deal with variables:

1. Variables will not be designated by a name, instead just by a memory address (this is typical in most processors at the lower-level of programming)
2. All variables will be stored at the beginning of the memory array.
3. To access a variable requires the > command a certain number of times to get to that spot. After the variable has been accessed we will return The Pointer to zero so that its ready for the next time to access a different variable. If this wasn't done, it would be difficult to predict where the pointer would be during different parts of the program.

    Since the program a=10; only contains a single variable we will only have to use one memory location. And since a Brainfuck computer should be initialized (on power-up) to zero, we can take for granted that The Pointer will already be poiting to zero, thus

+ + + + + + + + + +

is our finished program. All this program does is increments the value at The Pointer ten times. Since The Pointer starts off pointing to the first memory cell in the memory array (location zero) and since the value of all of the memory cells are also set to zero at power-up, we know that by performing ten "+" commands we increases the value of the first memory cell from zero to ten. So what about multiple variable programs? Consider the next example:

a=10;
b=5;
c=3;

    In this program, values 10, 5, and 3 are assigned to variable names a, b, and c respectively. In Brainfuck this operation would be performed by the following code...

+ + + + + + + + + + > + + + + + > + + + < <

    The first ten commands are identical to the previous example. They assign the value "10" to the first memory location. The next command increments The Pointer so that it is now pointing to the second memory address, which is then followed by five more "+" commands. So now the first memory locations holds a value of 10 and the second holds a value of 5. Then there is another > command incrementing The Pointer again to point to the third memory address which is then assigned a value of three. Now all "variables" are initilialized. What about the last "<<" part of the program? This is used to "point" The Pointer back to the first memory address, location zero, so that later extensions in the program, if it were to be added on to, would start from zero and could easily be redirected since the programmer would always know its start location at any given time. The draw back to this programming approach is that in some cases the "reset pointer to zero" technique is not necessary and wastes time. For example, the code fragment <<>> sends The Pointer back two spaces and then forward two spaces, completely cancelling out. A Brainfuck compiler should be set to detect such instances and delete them*, since they are normally a waste of time.

* In some cases the programmer may have intended the <<>> to cause a time delay before jumping to another part of the program. In which case, the compiler automatically erasing that part of the program could cause undesirable effects.

     Now that a general strategy of variable declaration has been established, we can now move on to more complicated Brainfuck programming. The next example will explain how to create a move function which will move the contents of one memory location to another. This is the premise of another important function -  copy. Below is the pseudo-code.

a=10;
move a to b;

    The value of 10 is assigned to variable a. Then the contents of variable a are moved to variable b. By doing so the previous contents of variable a are lost. If they were not lost the function would be a copy. The Brainfuck implementation is the following:

+ + + + + + + + + + [ - > + < ]
    The blue portion is the initialization, which assigns the value of 10 to the first memory location. The red part can be considered a loop similar to most programming languages as:

while(a!=0)
{
    a--;
    b++;
}
    For a more detailed explanation of why and how [->+<] works, read the Brainfuck - Part 1 page, which contains the instruction set and description.

    Remember, by moving the value of the first memory address to the second, the first is lost. If this is undesirable, the copy function is required. It works using a similar structure but instead involves a temporary variable, as in the following example:

a=10;
move a to c;
move c to (a and b);

    In C++ and many other "normal" languages all the programmer would have to do is
a=10;
b=a;

    Now in Brainfuck...

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

    The green section initializes the first memory location(a) to a value of 10. The red section is the loop which moves the value at the first memory location(a) to the third(c). Since after the "red" loop is completed The Pointer will be pointing to zero, the yellow section makes The Pointer point to the third memory location(c) so that the blue section will be ready. The blue section then moves the value at the third memory location(c) to both the first(a) and the second(b) memory location. So, after the program is complete memory location(c) is empty and location(a and b) are equal! The black section cleans things up making future additions to the code easier by returing The Pointer back to the first memory location, also known as location 0 or "variable" a in this case.


YOU ARE AT: Brainfuck - PART 2
BACK: BRAINFUCK - PART 1
NEXT: BRAINFUCK - PART 3

Coming Soon:

How to create a Brainfuck simulator on your computer
How to program a microncontroller to act like a Brainfuck processor
How to build a Brainfuck processor

>>HOME:
Programming
>>OTHER CATEGORIES:

ElectronicsProcessors