/*
 Si consideri la Sintassi Astratta sotto, per il Lambda Calcolo:
 Lambda::= Var | Const | [$] Var Lambda | [@] Lambda Lambda
 dove usiamo $ per l'astrazione e @ per l'applicazione.
 ....

 LastT.c è il modulo delle procedure del modulo header, LastT.h, che fornisce
 l'implementazione
 di 5 nuovi tipi:
 VartT, ConstT, AbsT, AppT, LastT
 I tipi ide e num possono essere direttamente implementati con i tipi string
 e int, in analogia a quanto fatto in laboratorio per i ParseTree in C.
 Il tipo LastT introduce alberi astratti il Lambda Calcolo. Questo ipo deve
 contenere 4 distinti tipi di alberi astratti per i diversi tipi di termini
 del Lambda Calcolo.

 COMPILAZIONE: Utiizzare opzione syntax del compilatore
        cc Last.c -fsyntax-only
 in altri compilatori, ad es. gcc, controllare nome della option mediante
 comando man, ad es. man gcc.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Last.h"

int main() {
    char X[2], Y[2];
    X[0] = 'x';
    Y[0] = 'y';

    LastT s = mkAbs(getIde(mkConst(X)), mkAbs(getIde(mkConst(Y)), mkApp(mkConst(X), mkConst(Y))));

    printAST(s);

    printf("\n");

    return 0;
}

//Le operazioni su LastT.c:
// mkConst, mkVar, mkAbs, mkApp, isConst, isVar, isAbs, isApp
// printAST, getIde, getTem, getFun, getArg

LastT mkConst(char* c){
    LastT newEl = NULL;

    newEl = malloc(sizeof(LastT));
    newEl->flag = Const;
    newEl->term.C.name = c;

    return newEl;
}

LastT mkVar(char* x){
    LastT newEl = NULL;

    newEl = malloc(sizeof(LastT));
    newEl->flag = Var;
    newEl->term.V.name = x;

    return newEl;
}

LastT mkAbs(char* x, LastT t){
    LastT newEl = NULL;

    newEl = malloc(sizeof(LastT));
    newEl->flag = Abs;
    newEl->term.A.name = x;
    newEl->term.A.term = t;

    return newEl;
}

LastT mkApp(LastT t1, LastT t2){
    LastT newEl = NULL;

    newEl = malloc(sizeof(LastT));
    newEl->flag = App;
    newEl->term.P.fun = t1;
    newEl->term.P.arg = t2;

    return newEl;
}

bool isConst(LastT t){
    return (t->flag == Const);
}

bool isVar(LastT t){
    return (t->flag == Var);
}

bool isAbs(LastT t){
    return (t->flag == Abs);
}

bool isApp(LastT t){
    return (t->flag == App);
}

void printAST(LastT t){
    printf("[");

    if (isConst(t) || isVar(t))
        printf("%c", getIde(t)[0]);

    else if (isAbs(t)) {
        printf("$-([%c],", getIde(t)[0]);
        printAST (getTerm(t));
        printf(")");
    }

    else if (isApp(t)) {
        printf("@-(");
        printAST(getFun(t));
        printf(",");
        printAST(getArg(t));
        printf(")");
    }

    printf("]");
}

char* getIde(LastT t){
    if (isConst(t))
        return t->term.C.name;
    else if (isVar(t))
        return t->term.V.name;
    else if (isAbs(t))
        return t->term.A.name;
}

LastT getTerm(LastT t){
    if (isAbs(t))
        return t->term.A.term;
}

LastT getFun(LastT t){
    if (isApp(t))
        return t->term.P.fun;
}

LastT getArg(LastT t){
    if (isApp(t))
        return t->term.P.arg;
}