Codebaum

Codes sind von ihrer Struktur her wie Datenbäume aufgebaut. Aus diesem Grund erzeugt der Parser ein Codebaum. Es könnte auch ein komplettes Programm als Codebaum abgebildet werden.
Bei der Ausführung oder linearen Umsetzung des Codebaumes wird ein Endknoten gesucht und dieser dann Schritt für Schritt nach vorne aufgelöst bis zum Wurzelknoten. Es ist eine rekursive Suche genauso wie wenn man Unterverzeichnisse nach Dateien durchsucht.
Einzig die Sprungbefehle wie GoTo lassen sich nicht so einfach in Codebäumen abbilden, sie müßten wie Flußdiagramme abgebildet werden und bilden so die sogenannten unstrukturierten Spaghetti-Codes die ein Programmierer unbedingt verhindern sollte.

Die Umsetzung kann dann etwa so aussehen:
Die Operationen sind grafisch so angeordnet, das sie von Rechts nach Links abgearbeitet werden können.

(Da in diesen Beispielen die Zuweisungsvariable A innerhalb der Berechnungen nicht verwendet wird kann Temp1 durch A ersetzt und so optimiert werden. "A = Temp1" fällt dann dadurch weg.)

[=] +-- (A)
    |
    +-- [+] +-- (B)
            |
            +-- [*] +-- (C)
                    |
                    +-- [^] +-- (D)
                            |
                            +-- (4)


Temp1 = D ^ 4
Temp1 = C * Temp1
Temp1 = B + Temp1
A = Temp1

[=] +-- (A)
    |
    +-- [^] +-- [*] +-- [+] +-- (B)
            |       |       |
            |       |       +-- (C)
            |       |
            |       +-- (D)
            |
            +-- (4)


Temp1 = B + C
Temp1 = Temp1 * D
Temp1 = Temp1 ^ 4
A = Temp1

[=] +-- (A)
    |
    +-- [*] +---------- [+] +-- (B)
            |               |
            |               +-- (C)
            |
            +-- [-] +-- (D)
                    |
                    +-- (4)


Temp1 = B + C
Temp2 = D - 4
Temp1 = Temp1 * Temp2
A = Temp

[=] +-- (A) <-- [*] +-- (G)
    |               |
    |               +-- (2)
    |
    +------------------ [-] +-- (B)
                            |
                            +-- [+] +-- [/] +-- (C)
                                    |       |
                                    |       +-- [*] +-- [^] +-- (D)
                                    |               |       |
                                    |               |       +-- (E)
                                    |               |
                                    |               +-- (F)
                                    |
                                    +-- (4)

Temp1 = D ^ E
Temp1 = Temp1 * F
Temp1 = C / Temp1
Temp1 = Temp1 + 4
Temp1 = B - Temp1
Pointer = G * 2
A[Pointer] = Temp1

[=] +-- (A) <-- [*] +-- (G)
    |               |
    |               +-- (2)
    |
    +-------------------[+] +-- [-] +-- (B)
                            |       |
                            |       +-- [*] +-- [/] +-- (C)
                            |               |       |
                            |               |       +-- [^] +-- (D)
                            |               |               |
                            |               |               +-- (E)
                            |               |
                            |               +-- (F)
                            |
                            +-- (4)

Temp1 = D ^ E
Temp1 = C / Temp1
Temp1 = Temp1 * F
Temp1 = B - Temp1
Temp1 = Temp1 + 4
Pointer = G * 2
A[Pointer] = Temp1

[IF] +---------- [<?>] +-- (A)
     |                 |
     |                 +-- (B)
     |
     |(True)
     +-- [=] +-- (C)
     |       |
     |       +-- (1)
     |
     |(False)
     +-- [=] +-- (C)
             |
             +-- (0)


Temp = TEST(A, B)
IF NOT Temp THEN GOTO J_False
J_True:
  C = 1
GOTO J_End
J_False:
  C = 0
J_End: