%{

open Ast

%}
%token <string*int> INT IDENT TYPE STRING
%token EOF
%token <int> NEW
%token <int> LET IN
%token <int> DOT
%token <int> AT
%token <int> NEGATE
%token <int> ISVOID
%token <int> TIMES DIVIDE
%token <int> PLUS MINUS
%token <int> EQUALS LESSEQUAL LESSTHAN
%token <int> NOT
%token <int> GETS RARROW

%token <int> CLASS INHERITS
%token <int> LBRACE RBRACE
%token <int> LPAREN RPAREN
%token <int> OF IF THEN ELSE ENDIF
%token <int> CASE ENDCASE RARROW
%token <int> WHILE BEGINLOOP ENDLOOP
%token <int> TRUE FALSE
%token <int> SEMIC COLON COMMA

%nonassoc NEW
%left DOT
%left AT
%nonassoc NEGATE
%nonassoc ISVOID
%left TIMES DIVIDE
%left PLUS MINUS
%nonassoc EQUALS LESSEQUAL LESSTHAN
%nonassoc NOT
%right GETS
//BULLSHIT(?)
%left IN

%start main
%type <Ast.ast> main
%%
main:
   | class_list { Ast($1) }

class_list:
   | class_def SEMIC class_list { $1 :: $3 }
   | { [] }

class_def:
   | CLASS TYPE LBRACE feature_list RBRACE
                   { Class($4) }
   | CLASS TYPE INHERITS TYPE LBRACE feature_list RBRACE
                   { Class($6) }

feature_list:
   | feature SEMIC feature_list { $1 :: $3 }
   | { [] }

feature:
   | IDENT COLON TYPE                  { let identname,_ = $1 in
                                         let typename,_ = $3 in
                                         Field(identname,typename,None) }

   | IDENT COLON TYPE GETS expr        { let identname,_ = $1 in
                                         let typename,_ = $3 in
                                         Field(identname, typename, Some($5)) }

   | IDENT LPAREN RPAREN COLON TYPE LBRACE expr RBRACE
                                       { let ident,_ = $1 in
                                         let return,_ = $5 in
                                         Method (ident,[],return,$7) }

   | IDENT LPAREN formal_list RPAREN COLON TYPE LBRACE expr RBRACE
                                       { let ident,_ = $1 in
                                         let return,_ = $6 in
                                         Method (ident,$3,return,$8) }



formal_list:
   | formal COMMA formal_list { $1 :: $3 }
   | formal { [$1] }

formal:
   | IDENT COLON TYPE { let name1,line1 = $1 in
                        let name2,line2 = $3 in
                        Formal(name1,name2,$2) }

expr:
   | IDENT GETS expr     { let name,line = $1 in
                           Assign(name, $3, line) }

   | expr AT maybe_type DOT IDENT LPAREN arg_list RPAREN
                         { let name,line = $5 in
                           Cast($1,$3, name, $7, line) }
   | IDENT LPAREN arg_list RPAREN
                         { let name,line = $1 in
                           Call(name, $3, $2) }
   | IF expr THEN expr ELSE expr ENDIF
                         { If($2, $4, $6) }
   | WHILE expr BEGINLOOP expr ENDLOOP
                         { While($2,$4) }
   | LBRACE block_list RBRACE
                         { Block($2) }
   | LET let_list IN expr
                         { Let($2,$4,$1) }
   | CASE expr OF case_list ENDCASE
                         { Case($2, $4, $3) }
   | NEW TYPE            { let name,line = $2 in
                           New(name,line) }
   | ISVOID expr         { IsVoid($2,$1) }
   | expr PLUS expr      { Plus($1,$3,$2) }
   | expr MINUS expr     { Minus($1,$3,$2) }
   | expr TIMES expr     { Times($1,$3,$2) }
   | expr DIVIDE expr    { Divide($1,$3,$2) }
   | NEGATE expr         { Negate($2,$1) }
   | expr LESSTHAN expr  { Less($1,$3,$2) }
   | expr LESSEQUAL expr { LessEqual($1,$3,$2) }
   | expr EQUALS expr    { Equal($1,$3,$2) }
   | NOT expr            { Not($2,$1) }
   | LPAREN expr RPAREN  { $2 }
   | IDENT               { let name,line = $1 in
                           Identifier(name,line) }
   | INT                 { let name,line = $1 in
                           Integer(name,line) }
   | STRING              { let name,line = $1 in
                           String(name,line) }
   | TRUE                { True($1) }
   | FALSE               { False($1) }

let_list:
   | let_ COMMA let_list { $1 :: $3 }
   | let_ { [] }

let_:
   | formal GETS expr {  ($1,Some($3)) }
   | formal { ($1,None) }


arg_list:
   | expr COMMA arg_list { $1 :: $3 }
   | expr { [$1] }

maybe_type:
   | TYPE { let name,line = $1 in Some(name) }
   | { None }

block_list:
   | expr SEMIC block_list { $1 :: $3 }
   | { [] }


case_list:
   | case SEMIC case_list { $1 :: $3 }
   | case SEMIC { [$1] }

case:
   | IDENT COLON TYPE RARROW expr { let idname,idline = $1 in
                                    let typename,typeline = $3 in
                                    CaseCase(idname,typename,$5,idline) }