parser.y

%{
#include <stdio.h>
#include <stdlib.h>

int yylex(void);
void yyerror(char *s);

int depth = 0;
extern int yylineno;
void scope_in(void) { depth++; printf("[SCOPE IN]  Depth: %d\n", depth); }
void scope_out(void) { printf("[SCOPE OUT] Depth: %d\n", depth); depth--; }
%}

%token INT FLOAT CHAR DOUBLE BOOL CONST VOID
%token INTEGER BOOLEAN DECIMAL VARIABLE CHARACTER_LITERAL
%token WHILE IF ELSE FOR DO SWITCH CASE DEFAULT
%token BREAK CONTINUE RETURN
%token INC DEC
%token AND OR NOT
%token GE LE EQ NE
%token ADDASS MINASS MULASS DIVASS MODASS

%nonassoc IFX
%nonassoc ELSE

%right '=' ADDASS MINASS MULASS DIVASS MODASS
%left OR
%left AND
%left GE LE EQ NE '>' '<'
%left '+' '-'
%left  '*' '/' '%'
%right '!' UMINUS
%left  INC DEC


%%

program:
      /* empty */
  |   program stmt_top
  ;

stmt_top:
      func_def
  |   stmt_list
  ;

stmt_list:
      stmt
  |   stmt_list stmt
  ;


stmt:
        ';'
    |   expr ';'
    |   FOR '(' for_init ';' opt_expr ';' opt_expr ')' stmt
    |   WHILE '(' expr ')' stmt
    |   DO stmt WHILE '(' expr ')' ';'
    |   IF '(' expr ')' stmt %prec IFX
    |   IF '(' expr ')' stmt ELSE stmt
    |   SWITCH '(' expr ')' '{' case_list '}'
    |   block
    |   BREAK ';'
    |   CONTINUE ';'
    |   RETURN expr ';'
    |   RETURN ';'
    |   type init_declarator_list ';'
    |   CONST type const_declarator_list ';' 
    ;

for_init:
        type init_declarator_list
    |   opt_expr
    ;

opt_expr
    : expr_list
    | /* empty */
    ;

expr_list
    : expr
    | expr_list ',' expr
    ;
expr:
        INTEGER
    |   BOOLEAN
    |   DECIMAL
    |   CHARACTER_LITERAL
    |   lvalue
    |   lvalue '=' expr
    |   lvalue ADDASS expr
    |   lvalue MINASS expr
    |   lvalue MULASS expr
    |   lvalue DIVASS expr
    |   lvalue MODASS expr
    |   lvalue INC
    |   lvalue DEC
    |   INC lvalue
    |   DEC lvalue
    |   '!' expr
    |   '-' expr %prec UMINUS
    |   expr '+' expr
    |   expr '-' expr
    |   expr '*' expr
    |   expr '/' expr
    |   expr '%' expr
    |   expr '<' expr
    |   expr '>' expr
    |   expr GE expr
    |   expr LE expr
    |   expr NE expr
    |   expr EQ expr
    |   expr AND expr
    |   expr OR expr
    |   '(' expr ')'
    |   VARIABLE '(' arg_list_opt ')'
    ;

lvalue
    : VARIABLE
    | '(' lvalue ')'
    ;
type:
      INT
    | FLOAT
    | CHAR
    | DOUBLE
    | BOOL
    | VOID
    ;

init_declarator_list:
    init_declarator
    | init_declarator_list ',' init_declarator
    ;

init_declarator:
      lvalue
    | lvalue '=' expr
    ;

const_declarator_list:
      const_item
    | const_declarator_list ',' const_item
    ;

const_item:
      lvalue '=' expr
    ;


case_list:
        case_item
    |   case_list case_item
    ;

case_item:
     CASE expr ':' stmt_list
    | CASE expr ':'
    | DEFAULT ':' stmt_list
    | DEFAULT ':' 
    | /* empty */
    ;

/* functions --abosamrar*/

func_def:
    type VARIABLE '(' param_list_opt ')' block
    ;

param_list_opt:
       param_list 
    |  /* empty */
    ;

param_list:
        param
    |   param_list ',' param
    ;

param:
        type VARIABLE
    |   type VARIABLE '=' expr /*3ashan el default*/
    ;

block:
        '{' {scope_in();} block_list_opt '}' {scope_out();}
    ;

block_list_opt:
        block_list
    |   /* empty */  
    ;

block_list:
        stmt
    |   block_list stmt
    ;

arg_list_opt:
        arg_list
    |   /* empty */
    ;

arg_list:
        expr
    |   arg_list ',' expr
    ;



%%

void yyerror(char *s) {
    fprintf(stderr, "Error at line %d: %s\n", yylineno, s);
}

int main(void) {
    yyparse();
    return 0;
}