spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// _x = 1

Expression* Snippet::parseAssign(){
    auto assign = new Assign();

    assign->left = parseExpr(); // links wird der Teil hinter dem = angehangen (parseExpr findet aktuell Variablen und Werte)

    auto current = currentToken; // aktuellen Index speichern
    currentToken = leftToken; // auf Anfang des linken Bereichs springen

    assign->right = parseVariable(); // Variablennamen rechts anhängen

    currentToken = current; // wieder zurück...
    leftToken = current;

    assign->left->parent = assign; // Tree vervollständigen
    assign->right->parent = assign;

    return assign; // assign zurückgeben
}

Quellcode

_x = 1-2+3

Quellcode

A -> B
B -> C=D
C -> _                  Variable
D -> E+E | E-E | E
E -> int                Wert

Quellcode

           A
           |
           B
           |
           =
          / \
         D   C
        /
       E-E
        |
        -
       / \
      E   E
     /     \
    1      E+E
            |
            +
           / \
          E   E
         /     \
        2       3

Quellcode

val     1
val     2
val     3
add     =        5
sub     =        -4
use     0                                   # 0 = _x
assign
----------------
-4                      # Wert in _x

C-/C++-Quelltext

const std::string& Snippet::get() // aktuelle Token als String
bool Snippet::next() // weiter, wenn Ende der Token erreicht -> false
bool Snippet::accept(const std::string &token) // gibt true wenn der aktuelle Token übereinstimmt
bool Snippet::expect(const std::string &token) // wie accept(), wirft allerdings Fehler und erhöht Token-Zähler

Expression* Snippet::parseExpr(){
    auto result = parseAssign(); // aktuell können wir nur das

    return result;
}

Expression* Snippet::parseValue(){ // liest Wert in Value Knoten
    auto value = new Value();
    value->value = get();
    next();

    return value;
}

Expression* Snippet::parseVariable(){ // liest Namen in Variable Knoten
    expect("_");

    auto variable = new Variable();
    variable->name = get();
    next();

    return variable;
}

Expression* Snippet::parseAssign(){
    auto result = new Assign();

    result->right = parseVariable(); // die Variable wird rechts angehangen, damit sie direkt vor dem assign gebunden wird
    expect("=");
    result->left = parseArith(); // links alles andere (aktuell nur ein aritmetischer Ausdruck)

    return result;
}

Expression* Snippet::parseArith(){ // akzeptiert + oder -, gibt ansonsten einen Wert zurück (Value Knoten)
    Expression* result = 0;

    auto current = currentToken;
    next(); // wir müssen "in die Zukunft schauen"

    if(accept("+")){
        currentToken = current; // und später wieder zurück...

        result = new Add();

        result->left = parseValue(); // links muss ein Wert stehen
        expect("+"); // dann muss der Operator kommen (den wir vorher akzeptiert haben)
        result->right = parseArith(); // und jetzt kann ein anderer Ausdruck kommen...
    }
    else if(accept("-")){
        currentToken = current;

        result = new Sub();

        result->left = parseValue();
        expect("-");
        result->right = parseArith();
    }
    else{
        currentToken = current;

        result = parseValue(); // ich gehe noch davon aus dass es sich somit um einen Wert handeln muss
    }

    return result;
}

Quellcode

_x = 5 # findet =, parsed eine Zuweisung, speichert den mini tree
print _x # findet print, parsed print und speichert wieder