Grammaire OK

expr_grammar_action.g

@@ -10,7 +10,7 @@ non-terminals ADD_EXPRS ADD_EXPR
 non-terminals MUL_EXPRS MUL_EXPR
 non-terminals CMP_EXPRS CMP_EXPR
 non-terminals EQ_EXPRS EQ_EXPR
-non-terminals BLOC
+
 axiom S
 {
 
@@ -22,72 +22,80 @@ axiom S
   open Utils
 
   (* TODO *)
-  let resolve_associativity term other =
+  let rec resolve_associativity term other =
        (* TODO *)
-    term
-
+       match other with 
+       | [] -> term
+       | (op,arg)::r -> resolve_associativity (Node (op,[term]@[arg])) r
+(*List.fold_left (fun acc elt -> let tag ,tree = elt in Node(tag,[acc]@[tree])) term other *)
 
 }
 
 rules
-S -> FUNDEFS SYM_EOF {  Node (Tlistglobdef, []) }
-FUNDEFS -> FUNDEF
+S -> FUNDEFS SYM_EOF {  Node (Tlistglobdef, $1) }
+
+FUNDEFS -> FUNDEF FUNDEFS { $1 :: $2}
+FUNDEFS -> {[]}
 
-FUNDEF -> SYM_IDENTIFIER SYM_LPARENTHESIS LPARAMS SYM_RPARENTHESIS INSTR
+FUNDEF -> IDENTIFIER SYM_LPARENTHESIS LPARAMS SYM_RPARENTHESIS INSTR {Node (Tfundef, [$1;Node(Tfunargs,$3);$5])}
 
-LPARAMS -> SYM_IDENTIFIER REST_PARAMS
-LPARAMS -> 
+LPARAMS -> IDENTIFIER REST_PARAMS {Node(Targ,[$1]) :: $2}
+LPARAMS -> {[]}
 
-REST_PARAMS -> SYM_COMMA SYM_IDENTIFIER REST_PARAMS
-REST_PARAMS ->
+REST_PARAMS -> SYM_COMMA IDENTIFIER REST_PARAMS {Node (Targ,[$2]) :: $3}
+REST_PARAMS -> {[]}
+ 
+INSTR -> IDENTIFIER SYM_ASSIGN EXPR SYM_SEMICOLON {Node (Tassign, [Node (Tassignvar,[$1; $3])])}
+INSTR -> SYM_IF SYM_LPARENTHESIS EXPR SYM_RPARENTHESIS LINSTRS ELSE { Node (Tif, [$3;$5]@$6)} 
+INSTR-> SYM_WHILE SYM_LPARENTHESIS EXPR SYM_RPARENTHESIS INSTR {Node (Twhile, [$3;$5])}
+INSTR -> SYM_RETURN EXPR SYM_SEMICOLON {Node (Treturn, [$2])}
+INSTR -> SYM_PRINT EXPR SYM_SEMICOLON {Node (Tprint, [$2])}
+INSTR -> LINSTRS {$1}
 
-INSTR -> SYM_IDENTIFIER SYM_ASSIGN EXPR SYM_SEMICOLON
-INSTR -> SYM_IF SYM_LPARENTHESIS EXPR SYM_RPARENTHESIS SYM_LBRACE INSTR SYM_RBRACE ELSE
-INSTR-> SYM_WHILE SYM_LPARENTHESIS EXPR SYM_RPARENTHESIS INSTR 
-INSTR -> SYM_RETURN EXPR SYM_SEMICOLON
-INSTR -> SYM_PRINT EXPR SYM_SEMICOLON
-INSTR -> BLOC
+EXPR -> EQ_EXPR EQ_EXPRS { resolve_associativity $1 $2}
 
-EXPR -> CMP_EXPR CMP_EXPRS
+CMP_EXPR -> ADD_EXPR ADD_EXPRS { resolve_associativity $1 $2}
 
-CMP_EXPR -> ADD_EXPR ADD_EXPRS
+ADD_EXPR -> MUL_EXPR MUL_EXPRS { resolve_associativity $1 $2}
 
-ADD_EXPR -> MUL_EXPR MUL_EXPRS
+EQ_EXPR -> CMP_EXPR CMP_EXPRS { resolve_associativity $1 $2}
 
-MUL_EXPR -> FACTOR
+MUL_EXPR -> FACTOR {$1}
+MUL_EXPR -> SYM_MINUS FACTOR {Node (Tneg,[$2])}
 
-FACTOR -> SYM_INTEGER
-FACTOR -> SYM_IDENTIFIER
-FACTOR -> SYM_LPARENTHESIS EXPR SYM_RPARENTHESIS
+FACTOR -> INTEGER {$1}
+FACTOR -> IDENTIFIER {$1}
+FACTOR -> SYM_LPARENTHESIS EXPR SYM_RPARENTHESIS {$2}
 
-MUL_EXPRS -> SYM_ASTERISK MUL_EXPR MUL_EXPRS
-MUL_EXPRS -> SYM_DIV MUL_EXPR MUL_EXPRS
-MUL_EXPRS -> SYM_MOD MUL_EXPR MUL_EXPRS
-MUL_EXPRS ->
+MUL_EXPRS -> SYM_ASTERISK MUL_EXPR MUL_EXPRS { (Tmul,$2) :: $3 }
+MUL_EXPRS -> SYM_DIV MUL_EXPR MUL_EXPRS { (Tdiv,$2) :: $3 }
+MUL_EXPRS -> SYM_MOD MUL_EXPR MUL_EXPRS { (Tmod,$2) :: $3 }
+MUL_EXPRS -> {[]}
 
-ADD_EXPRS -> SYM_PLUS ADD_EXPR ADD_EXPRS
-ADD_EXPRS -> SYM_MINUS ADD_EXPR ADD_EXPRS
-ADD_EXPRS-> 
+ADD_EXPRS -> SYM_PLUS ADD_EXPR ADD_EXPRS { (Tadd,$2) :: $3 }
+ADD_EXPRS -> SYM_MINUS ADD_EXPR ADD_EXPRS { (Tsub,$2) :: $3 }
+ADD_EXPRS-> {[]}
 
-CMP_EXPRS -> SYM_EQUALITY MUL_EXPR MUL_EXPRS
-CMP_EXPRS -> SYM_NOTEQ MUL_EXPR MUL_EXPRS
-CMP_EXPRS -> SYM_GEQ MUL_EXPR MUL_EXPRS
-CMP_EXPRS -> SYM_GT MUL_EXPR MUL_EXPRS
-CMP_EXPRS -> SYM_LT MUL_EXPR MUL_EXPRS
-CMP_EXPRS -> SYM_LEQ MUL_EXPR MUL_EXPRS
+EQ_EXPRS -> SYM_EQUALITY MUL_EXPR MUL_EXPRS { (Tceq,$2) :: $3 }
+EQ_EXPRS -> SYM_NOTEQ MUL_EXPR MUL_EXPRS { (Tneg,$2) :: $3 }
+EQ_EXPRS -> {[]}
 
-EQ_EXPR -> SYM_INTEGER
-EQ_EXPR -> SYM_IDENTIFIER
-EQ_EXPR -> SYM_LPARENTHESIS EXPR SYM_RPARENTHESIS
+CMP_EXPRS -> SYM_GEQ MUL_EXPR MUL_EXPRS { (Tcge,$2) :: $3 }
+CMP_EXPRS -> SYM_GT MUL_EXPR MUL_EXPRS { (Tcgt,$2) :: $3 }
+CMP_EXPRS -> SYM_LT MUL_EXPR MUL_EXPRS { (Tclt,$2) :: $3 }
+CMP_EXPRS -> SYM_LEQ MUL_EXPR MUL_EXPRS { (Tcle,$2) :: $3 }
+CMP_EXPRS -> {[]}
 
-EQ_EXPRS -> SYM_EQUALITY EQ_EXPR
 
+INTEGER -> SYM_INTEGER {IntLeaf ($1)}
 
+IDENTIFIER -> SYM_IDENTIFIER {StringLeaf ($1)}
 
-ELSE -> SYM_ELSE BLOC
-ELSE -> 
+ELSE -> SYM_ELSE LINSTRS {[$2]}
+ELSE -> {[]}
 
-BLOC -> SYM_LBRACE INSTRS SYM_RBRACE
-INSTRS -> INSTR INSTRS
+LINSTRS -> SYM_LBRACE INSTRS SYM_RBRACE {Node (Tblock,$2)}
 
+INSTRS -> INSTR INSTRS { $1 :: $2}
+INSTRS -> {[]}