specification

-----------------

2dbf is to compare with with a cord. that you lay out like a specific pattern. The direction of that cord causes the command that is used. The 8 different directions comply with the 8 commands of the programming language Brainf*ck. To repeat a command you'll have to use numbers, which you can compare with nodes. The length of a part of that cord doesn't affect the repetition of a command. Only the cross sum of the numbers in a direction does matter. If there aren't any numbers at the beginning of a direction, the command will exactly be executed once (if you write a number later in that direction, it will be added to that 1). If you begin a shift of direction with a 0 (zero), this change will be ignored - which is very important for longer code.

Besides, the language only 'knows' 3 types of chars: Spaces, numbers and 'the rest'. Spaces are used to isolate the 'rest' from themself. 

2dbf is not a linear language, which means that the code is not interpreted line-by-line. The instructions depend on the shifts of direction. Remember the cord: The interpreter follows the pattern of the cord (and begins at the left upper corner, line 1 char 1). If the cord overlaps, the way the cord is 'layed' is important: It will follow the cord into the direction that has been used before (if that is possible): The cord starts at the upper left, it goes along to the lower right. Thus, the interpreter tries to keep the direction. If this is not possible, the program will be terminated. Because of this, branches like 

            *

           *

***********

           *

       *

are not possible, because the shift of direction is not clearly defined. This will cause an abort of the program. Sections like these

*

 *

*******

   *

    *

are clearly defined. 

The end (and the start) of a program is an absolutely isolated 'end of the cord', for example:

 

 * <- start    *

  *           *  <- end

   *5555552***

 

If you want a program to begin with a command that runs to the left, you'll have to use the 0: For example a simple echo program (char is typed, char is written ; ',.' ) could look like this:

*0********

         0 

 . ->  * *

      *  *

 , ->  * *

        **

         *  

The cord can be composed of all chars except for spaces. It has to begin in line 1 @ char 1. Numbers are used as 'repetition-operators', so they repeat the command subject to their value. A number placed on position 1,1 will be ignored.

Comments can be used everywhere, as long as there is no connection to the cord. If that is the case, comments will be interpreted as part of the cord, which often causes errors (in the form of a program abort). 

The maximum size of the source code depends on the interpreter: With 2DBFI you can use at least 10.000 lines with 200 chars per line.

2dbf is "turing-complete", which means that you can compute everything that you can compute with 'normal' programming languages.

The commands, which are defined by the direction, comply with the following commands used in Brainf*ck (the '.' shows where the cord begins, which is useful to see if you run from the left to the right or from the right to the left for example):

|----------------------------------|

|direction    | Brainf*ck-command  |

|----------------------------------|

|----------------------------------|

|.*****       |        +           |

|             |                    |

|to the right |     increment      |

|----------------------------------|

|*****.       |        -           |

|             |                    |

|to the left  |     decrement      |

|----------------------------------|

|.            |        >           |

| *           |                    |

|lower right  |  ArrInd-forward    |

|----------------------------------|

|  .          |        <           |

| *           |                    |

|lower left   |  ArrInd-backward   |

|----------------------------------|

| .           |        [           |

| *           |                    |

|downward     |  begin of loop     |

|----------------------------------|

| *           |        ]           |

| .           |                    |

|upward       |   end of loop      |

|----------------------------------|

|  *          |        .           |

| .           |                    |

|upper right  |     output         |

|----------------------------------|

| *           |        ,           |

|  .          |                    |

|upper left   |     input          |

|__________________________________|

 

In Brainf*ck, the language on that 2dbf builds up, you can navigate (with < and >) in an array of the size 30.000. At the beginning, every array element will be initialized with 0 and the pointer points on 0, too. With > the pointer can be moved to the next element, with < it can be moved backwards, but never into the negative array. + increases the actual array element (+1), - will decrease it. (size: 0-255). With , you can catch the ascii-value of the char pressed on your keyboard, the . is used to put the value out in ascii form (65 = A, for example. [ and ] are loop-operators. Their function is a bit too complicated to explain it exactly, but there are Brainf*ck tutorials which explain this pretty good.

 

2dbf is a development made by oCaS and Du-Ne and is supported by www.legacy-project.de and www.gcf.de

 

Have fun and good nerves with 2dbf!

[addition: I hope the translation is readable for english users ;-)]