backup

{FLOAT} { 
    yylval.node = newLeaf("FLOAT", strdup(yytext), yylineno);
    return FLOAT;
}
{INT} {
    yylval.node = newLeaf("INT", strdup(yytext), yylineno);
    return INT;
}
 
{CHAR} {
    
    yylval.node = newLeaf("CHAR",strdup(yytext), yylineno);
    return CHAR;    
}
 
{ID} {
    if (strcmp(yytext, "int") == 0 ||
            strcmp(yytext, "float") == 0 ||
            strcmp(yytext, "char") == 0) {
        yylval.node = newLeaf("TYPE", strdup(yytext), yylineno);
        return TYPE;
    }    
    else if (strcmp(yytext, "struct") == 0) {
        yylval.node = newLeaf("STRUCT", NULL, yylineno);
        return STRUCT;
    }
    else if (strcmp(yytext, "if") == 0) {
        yylval.node = newLeaf("IF", NULL, yylineno);
        return IF;
    }
    else if (strcmp(yytext, "else") == 0) {
        yylval.node = newLeaf("ELSE", NULL, yylineno);
        return ELSE;
    }
    else if (strcmp(yytext, "while") == 0) {
        yylval.node = newLeaf("WHILE", NULL, yylineno);
        return WHILE;
    }
    else if (strcmp(yytext, "return") == 0) {
        yylval.node = newLeaf("RETURN", NULL, yylineno);
        return RETURN;
    }
    else {
        yylval.node = newLeaf("ID", strdup(yytext), yylineno);
        return ID;
    }
}
 
{DOT} {
    yylval.node = newLeaf("DOT", NULL, yylineno);
    return DOT;
}
{SEMI} { 
    yylval.node = newLeaf("SEMI", NULL, yylineno);
    return SEMI;    
}
{COMMA} { 
    yylval.node = newLeaf("COMMA", NULL, yylineno);
    return COMMA;
}
{ASSIGN} { 
    yylval.node = newLeaf("ASSIGN", NULL, yylineno);
    return ASSIGN;
}
{LT} { 
    yylval.node = newLeaf("LT", "<", yylineno);
    return LT;
}
{LE} {
    yylval.node = newLeaf("LE", "<=", yylineno);
    return LE;
}
{GT} { 
    yylval.node = newLeaf("GT", ">", yylineno);
    return GT;    
}
{GE} { 
    yylval.node = newLeaf("GE", ">=", yylineno);
    return GE;
}
{NE} { 
    yylval.node = newLeaf("NE", "!=", yylineno);
    return NE;
}
{EQ} { 
    yylval.node = newLeaf("EQ", "==", yylineno);
    return EQ;
}
{PLUS} { 
    yylval.node = newLeaf("PLUS", NULL, yylineno);
    return PLUS;
}
{MINUS} { 
    yylval.node = newLeaf("MINUS", NULL, yylineno);
    return MINUS;    
}
{MUL} { 
    yylval.node = newLeaf("MUL", NULL, yylineno);
    return MUL;    
}
{DIV} { 
    yylval.node = newLeaf("DIV", NULL, yylineno);
    return DIV;
}
{AND} { 
    yylval.node = newLeaf("AND", NULL, yylineno);
    return AND;
}
{OR} { 
    yylval.node = newLeaf("OR", NULL, yylineno);
    return OR;
}
{NOT} { 
    yylval.node = newLeaf("NOT", NULL, yylineno);
    return NOT;
}
{LP} { 
    yylval.node = newLeaf("LP", NULL, yylineno);
    return LP;
}
{RP} { 
    yylval.node = newLeaf("RP", NULL, yylineno);
    return RP;
}
{LB} { 
    yylval.node = newLeaf("LB", NULL, yylineno);
    return LB;
}
{RB} { 
    yylval.node = newLeaf("RB", NULL, yylineno);
    return RB;
}
{LC} { 
    yylval.node = newLeaf("LC", NULL, yylineno);
    return LC;
}
{RC} { 
    yylval.node = newLeaf("RC", NULL, yylineno);
    return RC;
}



%union {
    node *node;
}
%nonassoc LOWER_ELSE
%nonassoc <node> TYPE STRUCT IF ELSE WHILE RETURN
%token <node> INT FLOAT CHAR ID
%token <node> LC RC
%right <node> ASSIGN
%left <node> AND 
%left <node> OR 
%left <node> LT LE GT GE NE EQ
%left <node> PLUS MINUS
%left <node> MUL DIV
%right <node> NOT
%left <node> LP RP LB RB DOT
%token <node> SEMI COMMA

%type <node> Program ExtDefList ExtDef ExtDecList Specifier StructSpecifier VarDec FunDec VarList ParamDec CompSt StmtList Stmt DefList Def DecList Dec Exp Args
%%
Program: ExtDefList {
        $$ = new_node("Program", 1, $1);
    }
    ;
ExtDefList: ExtDef ExtDefList {
        $$ = new_node("ExtDefList", 2, $1, $2);
    }
    | %empty {
        $$ = new_node(NULL, 0);
    }
    ;
ExtDef: Specifier ExtDecList SEMI {
        $$ = new_node("ExtDef", 3, $1, $2, $3);
    }
    | Specifier SEMI {
        $$ = new_node("ExtDef", 2, $1, $2);
    }
    | Specifier FunDec CompSt {
        $$ = new_node("ExtDef", 3, $1, $2, $3);
    }
    ;
ExtDecList: VarDec {
        $$ = new_node("ExtDecList", 1, $1);
    }
    | VarDec COMMA ExtDecList {
        $$ = new_node("ExtDecList", 3, $1, $2, $3);
    }
    ;

Specifier: TYPE {
         $$ = new_node("Specifier", 1, $1);
    } 
    | StructSpecifier {
         $$ = new_node("Specifier", 1, $1);
    }
    ;

StructSpecifier: STRUCT ID LC DefList RC {
        $$ = new_node("StructSpecifier", 5, $1, $2, $3, $4, $5);
    }
    |
    STRUCT ID {
        $$ = new_node("StructSpecifier", 2, $1, $2);
    }
    ;

VarDec: ID {
        $$ = new_node("VarDec", 1, $1);
    }
    | VarDec LB INT RB {
        $$ = new_node("VarDec", 4, $1, $2, $3, $4);
    }
    ;

FunDec: ID LP VarList RP {
        $$ = new_node("FunDec", 4, $1, $2, $3, $4);
    }
    | ID LP RP {
        $$ = new_node("FunDec", 3, $1, $2, $3);
    }
    ;
VarList: ParamDec COMMA VarList {
       $$ = new_node("VarList", 3, $1, $2, $3);
    }
    | ParamDec {
       $$ = new_node("VarList", 1, $1);
    }
    ;
ParamDec: Specifier VarDec {
        $$ = new_node("ParamDec", 2, $1, $2);
    }
    ;

CompSt: LC DefList StmtList RC {
        $$ = new_node("CompSt", 4, $1, $2, $3, $4);
    }
    ;
StmtList: Stmt StmtList {
        $$ = new_node("StmtList", 2, $1, $2);
    } 
    | %empty {
        $$ = new_node(NULL, 0);
    }
    ;
Stmt: Exp SEMI {
        $$ = new_node("Stmt", 2, $1, $2);
    }
    | CompSt {
        $$ = new_node("Stmt", 1, $1);
    }
    | RETURN Exp SEMI {
        $$ = new_node("Stmt", 3, $1, $2, $3);
    }
    | IF LP Exp RP Stmt %prec LOWER_ELSE {
        $$ = new_node("Stmt", 5, $1, $2, $3, $4, $5);
    }
    | IF LP Exp RP Stmt ELSE Stmt {
        $$ = new_node("Stmt", 7, $1, $2, $3, $4, $5, $6, $7);
    }
    | WHILE LP Exp RP Stmt {
        $$ = new_node("Stmt", 5, $1, $2, $3, $4, $5);
    }
    ;

DefList: Def DefList {
       $$ = new_node("DefList", 2, $1, $2);
    }
    | %empty {
       $$ = new_node(NULL, 0);
    }
    ;

Def: Specifier DecList SEMI {
        $$ = new_node("Def", 3, $1, $2, $3);
    }
    ;

DecList: Dec {
        $$ = new_node("DecList", 1, $1);
    }
    | Dec COMMA DecList {
        $$ = new_node("DecList", 3, $1, $2, $3);
    }
    ;

Dec: VarDec {
        $$ = new_node("Dec", 1, $1);
    }
    | VarDec ASSIGN Exp {
        $$ = new_node("Dec", 3, $1, $2, $3);
    }
    ;

Exp: Exp ASSIGN Exp {$$ = new_node("Exp", 3, $1, $2, $3);}
    | Exp AND Exp {$$ = new_node("Exp", 3, $1, $2, $3);}
    | Exp OR Exp {$$ = new_node("Exp", 3, $1, $2, $3);}
    | Exp LT Exp {$$ = new_node("Exp", 3, $1, $2, $3);}
    | Exp LE Exp {$$ = new_node("Exp", 3, $1, $2, $3);}
    | Exp GT Exp {$$ = new_node("Exp", 3, $1, $2, $3);}
    | Exp GE Exp {$$ = new_node("Exp", 3, $1, $2, $3);}
    | Exp NE Exp {$$ = new_node("Exp", 3, $1, $2, $3);}
    | Exp EQ Exp {$$ = new_node("Exp", 3, $1, $2, $3);}
    | Exp PLUS Exp {$$ = new_node("Exp", 3, $1, $2, $3);}
    | Exp MINUS Exp {$$ = new_node("Exp", 3, $1, $2, $3);}
    | Exp MUL Exp {$$ = new_node("Exp", 3, $1, $2, $3);}
    | Exp DIV Exp {$$ = new_node("Exp", 3, $1, $2, $3);}
    | LP Exp RP {$$ = new_node("Exp", 3, $1, $2, $3);}
    | MINUS Exp {$$ = new_node("Exp", 2, $1);}
    | NOT Exp {$$ = new_node("Exp", 2, $1, $2);}
    | ID LP Args RP {$$ = new_node("Exp", 4, $1, $2, $3, $4);}
    | ID LP RP {$$ = new_node("Exp", 3, $1, $2, $3);}
    | Exp LB Exp RB {$$ = new_node("Exp", 4, $1, $2, $3, $4);}
    | Exp DOT ID {$$ = new_node("Exp", 3, $1, $2, $3);}
    | ID {$$ = new_node("Exp", 1, $1);}
    | INT {$$ = new_node("Exp", 1, $1);}
    | FLOAT {$$ = new_node("Exp", 1, $1);}
    | CHAR {$$ = new_node("Exp", 1, $1);}
    | error {}
    ;

Args: Exp COMMA Args {$$ = new_node("Args", 3, $1, $2, $3);}
    | Exp {$$ = new_node("Args", 1, $1);}
    ;


%%