Erythro/src/Pointers.c

/*************/
/*GEMWIRE    */
/*    ERYTHRO*/
/*************/

#include <Defs.h>
#include <Data.h>

int PointerTo(int Type) {
    if((Type & 0xf) == 0xf)
        DieDecimal("Unrecognized type in pointerisation", Type);
    printf("\t\tPointerising a %s\n", TypeNames(Type));
    return (Type + 1);
}

int ValueAt(int Type) {
    printf("\t\tDereferencing a %s\n", TypeNames(Type));
    //TODO: this is still bullshittery!
    if((Type & 0xf) == 0x0)
        DieDecimal("Unrecognized type in defererencing", Type);
    return (Type - 1);
}

int ParseOptionalPointer(struct SymbolTableEntry** Composite) {

    int Type;
    
    switch(CurrentToken.type) {
        case TY_VOID:
            Type = RET_VOID;
            Tokenise();
            break;
        case TY_CHAR:
            Type = RET_CHAR;
            Tokenise();
            break;
        case TY_INT:
            Type = RET_INT;
            Tokenise();
            break;
        case TY_LONG:
            Type = RET_LONG;
            Tokenise();
            break;
        case KW_STRUCT:
            Type = DAT_STRUCT;
            *Composite = BeginStructDeclaration();
            break;
        default: 
            DieDecimal("Illegal type for pointerisation", CurrentToken.type);
    }
    // Recursively scan more *s
    // This makes things like:
    // x = **y;
    // possible.
    while(1) {
        Tokenise();
        printf("\t\t\tType on parsing is %d\n", CurrentToken.type);
        if(CurrentToken.type != AR_STAR)
            break;
        
        Type = PointerTo(Type);
        Tokenise();
    }

    return Type;
}

struct ASTNode* AccessArray() {
    struct ASTNode* LeftNode, *RightNode;
    struct SymbolTableEntry* Entry;

    printf("\tAccessing array %s as requested\r\n", CurrentIdentifier);
    if ((Entry = FindSymbol(CurrentIdentifier)) == NULL || Entry->Structure != ST_ARR)
        DieMessage("Accessing undeclared array", CurrentIdentifier);
    
    LeftNode = ConstructASTLeaf(OP_ADDRESS, Entry->Type, Entry, 0);
    //printf("\t\tCurrent token: %s\r\n", TokenNames[CurrentToken.type]);
    Tokenise();
    //printf("\t\tCurrent token: %s\r\n", TokenNames[CurrentToken.type]);

    RightNode = ParsePrecedenceASTNode(0);

    VerifyToken(LI_RBRAS, "]");

    if(!TypeIsInt(RightNode->ExprType))
        Die("Array index is not integer");
    
    printf("\t\tPreparing types - RightNode of type %s must be mutated to LeftNode type %s\r\n", (RightNode->ExprType), TypeNames(LeftNode->ExprType));
    RightNode = MutateType(RightNode, LeftNode->ExprType, OP_ADD);

    LeftNode = ConstructASTNode(OP_ADD, Entry->Type, LeftNode, NULL, RightNode, NULL, 0);
    printf("\tAccessArray: Preparing LeftNode for dereference.\r\n");
    LeftNode = ConstructASTBranch(OP_DEREF, ValueAt(LeftNode->ExprType), LeftNode, NULL, 0);
    printf("\tArray Access constructed\r\n");
    return LeftNode;
}