feat(parser/lexer): Complete parser/lexer

src/parser_laurian/.gitignore

@@ -0,0 +1 @@
+*.output

src/parser_laurian/Makefile

@@ -26,7 +26,7 @@ lexer.ml: lexer.mll lang.cmo
 	ocamllex $<
 
 parser.ml parser.mli: parser.mly lang.cmo
-	ocamlyacc $<
+	ocamlyacc -v $<
 
 lexer.cmo: lexer.ml parser.cmo
 	ocamlc -c $<

src/parser_laurian/Tests/progsimple.c

@@ -1,12 +1,20 @@
-void main (string y, int x) {
+void yes( int yes){
+    yes = 5;
+    return yes; 
+}
+
+void main (string y, int x, int yooo) {
     x = 15;
     while (x < 20) {
-        x = x + 1;
+        x = x + 1 -16;
         y = "hello";
         if (x == 17) {
             y = "world";
         }
-        /*  */
     }
+
+    yooo = yes(5);  
+
     return x;
 }
+

src/parser_laurian/lexer.mll

@@ -39,7 +39,7 @@ rule token = parse
 | "string" {TP(StringT)}
 | "float" {TP(FloatT)}
 | "void" {TP(VoidT)}
-| "lit" {TP(LitT)}   (* Potentiellement list *) 
+| "lit" {TP(LitT)} (* faut demander *)   
 
 | '('  { LPAREN }
 | ')'  { RPAREN }
@@ -73,16 +73,16 @@ rule token = parse
 | "while" {WHILE}
 | "for" {FOR}
 
-| "true" {BCONSTANT(true)}
+| "True" {BCONSTANT(true)}
-| "false" {BCONSTANT(false)}
+| "False" {BCONSTANT(false)}
-| num_virgule as s {FLOATCONSTANT(float_of_string s)}
-| num as s {INTCONSTANT(int_of_string s)}
-| literal as l    { LITCONSTANT l }
-| str as s    { STRINGCONSTANT s }
 
 
 | eof          {EOF}
 
+| num_virgule as s {FLOATCONSTANT(float_of_string s)}
+| num as s {INTCONSTANT(int_of_string s)}
+| literal as l    { LITCONSTANT l }
+| str as s    { STRINGCONSTANT s }
 | alph alph* as i  {IDENTIFIER i} 
 
 | _  {Printf.printf "ERROR: unrecogized symbol '%s'\n" (Lexing.lexeme lexbuf);

src/parser_laurian/parser.mly

@@ -15,24 +15,31 @@ open Lang
 %token IF ELSE WHILE FOR RETURN BCEQ BCGE BCGT BCLE BCLT BCNE BLAND BLOR
 %token EOF
 
+%left QMARK COLON
 %left BLOR
 %left BLAND
 %left BCEQ BCNE
 %left BCGE BCGT BCLE BCLT
 %left PLUS MINUS FPLUS FMINUS
 %left TIMES DIV FDIV FTIMES MOD
-%left LPAREN RPAREN LBRACE RBRACE
+
 
 %right IF ELSE
-%right WHILE FOR
+%left RPAREN
-%right RETURN
+%right LPAREN
+%left SEMICOLON
 
 %start start
 %type <Lang.prog> start
 
 %%
 
-start: fundefn {  Prog ([], [$1]) }
+start: list_fundefn {  Prog ([], $1) }
+  ;
+
+list_fundefn:
+ | {[]}
+ | fundefn list_fundefn {$1 :: $2}
 ;
 
 fundefn:  /* Compound-statement dans la doc --> 6.8.2 */
@@ -61,46 +68,44 @@ constant:
   |FLOATCONSTANT {FloatV($1) }
 ;
 
-/*expression_opt:
- |{Skip}
- |expression {$1}
-;
-*/
 
 expression: /* A.2.1 ---> 6.5.1 */
-  |constant {Const($1)}
   |IDENTIFIER {VarE($1)}
+  |constant {Const($1)}
   |LPAREN expression RPAREN {$2}
   |multiplicative_expression {$1}
   |additive_expression {$1}
   |relational_expression {$1}
   |equality_expression {$1}
   |logical_and_expression {$1} 
+  |logical_or_expression {$1}
   |conditional_expression {$1}
+  |IDENTIFIER LPAREN expr_list RPAREN {CallE($1,$3)}
 ;
 
+
 /*les calculs*/
 multiplicative_expression: /* 6.5.5 */
-  |expression TIMES expression {BinOp(BArith(BAmul), $1, $3)}
   |expression FTIMES expression {BinOp(BArith(BAfmul), $1, $3)}
-  |expression DIV expression {BinOp(BArith(BAdiv), $1, $3)}
+  |expression TIMES expression {BinOp(BArith(BAmul), $1, $3)}
   |expression FDIV expression {BinOp(BArith(BAfdiv), $1, $3)}
+  |expression DIV expression {BinOp(BArith(BAdiv), $1, $3)}
   |expression MOD expression {BinOp(BArith(BAmod), $1, $3)}
 ;
 
 additive_expression: /* 6.5.6 */
-  |expression PLUS expression {BinOp(BArith(BAadd), $1, $3)}
-  |expression MINUS expression {BinOp(BArith(BAsub), $1, $3)}
   |expression FPLUS expression {BinOp(BArith(BAfadd), $1, $3)}
   |expression FMINUS expression {BinOp(BArith(BAfsub), $1, $3)}
+  |expression PLUS expression {BinOp(BArith(BAadd), $1, $3)}
+  |expression MINUS expression {BinOp(BArith(BAsub), $1, $3)}
 ;
 
 /*les comparaisons*/
 relational_expression: /* 6.5.8 */
+  |expression BCLT expression {BinOp(BCompar(BClt), $1, $3)}
+  |expression BCGT expression {BinOp(BCompar(BCgt), $1, $3)}
   |expression BCLE expression {BinOp(BCompar(BCle), $1, $3)}
   |expression BCGE expression {BinOp(BCompar(BCge), $1, $3)}
-  |expression BCGT expression {BinOp(BCompar(BCgt), $1, $3)}
-  |expression BCLT expression {BinOp(BCompar(BClt), $1, $3)}
 ;
 equality_expression: /* 6.5.9 */
   |expression BCEQ expression {BinOp(BCompar(BCeq), $1, $3)}
@@ -110,6 +115,9 @@ equality_expression: /* 6.5.9 */
 /*les operateurs booleens */ 
 logical_and_expression:
   |expression BLAND expression {BinOp(BBool(BBand), $1, $3)} /* 6.5.13 */
+;
+
+logical_or_expression:  
   |expression BLOR expression {BinOp(BBool(BBor), $1, $3)} /* 6.5.14 */
 ;
 
@@ -124,28 +132,32 @@ conditional_expression: /* 6.5.16 */
 /*///////////// DEBUT DES STATEMENTS //////////////////*/
 
 statement: /* A.2.3 ----> 6.8 */
-  |LBRACE block_item_list_opt RBRACE {$2} /* peut etre fundefn plutot vu que c'est le vrai compound_statement*/
+  |compound_statement {$1} /* peut etre fundefn plutot vu que c'est le vrai compound_statement*/
+  // |expression_statement {$1}
   |select_statement {$1} /*if et else*/
   |iteration_statement {$1} /*while et for*/
   |jump_statement SEMICOLON {$1} /*return et break*/
   |assignation SEMICOLON {$1}
+  |IDENTIFIER LPAREN expr_list RPAREN {CallC($1,$3)}
+
   // Faut faire l'appel à des foncttions avec CondC( fname * (expr_list ) )
 ;
 
+expr_list:
+  | { [] }
+  | expression expr_list{[$1] @ $2}
+;
+
+compound_statement: /* 6.8.2 */
+  |LBRACE block_item_list_opt RBRACE {$2}
+;
+
+
 block_item_list_opt: /* 6.8.2 */
-  |statement {$1}
+  |statement block_item_list_opt  {Seq($1,$2)} /* pas sur du tout */
-  |block_item_list_opt statement {Seq($1,$2)} /* pas sur du tout */
   |{Skip}
 ;
 
-
-
-block_item: /* 6.8.2 */
-  /* declaration de variable / function (A.2.2 dans la doc) */
-  |statement {$1}
-;
-
-
 select_statement:  /* 6.8.4 */
   |IF LPAREN expression RPAREN statement {CondC ($3, $5, Skip) }
   |IF LPAREN expression RPAREN statement ELSE statement {CondC ($3, $5, $7) }
@@ -153,7 +165,7 @@ select_statement:  /* 6.8.4 */
 
 iteration_statement: /* 6.8.5 */
   |WHILE LPAREN expression RPAREN statement {Loop (Seq (CondC ( $3, Skip, Exit), $5))}
-  /*|FOR LPAREN expression_opt SEMICOLON expression_opt SEMICOLON expression_opt RPAREN statement {Loop (Seq (CondC ( $5, Skip, Exit), $9))} */ /*Absolument pas sur*/
+  |FOR LPAREN expression SEMICOLON expression SEMICOLON expression RPAREN statement {Loop (Seq (CondC ( $5, Skip, Exit), $9))} /*Absolument pas sur*/
 ;
 
 jump_statement: /* 6.8.6 */
@@ -182,22 +194,7 @@ assignation: /* 6.5.17 */ /* dans la doc ça fait parti des expressions mais pg
   Demander au prof : 
 
 
- ---Comment on différencie "==" et "="
-
- ---Type LitT (peut etre list ?)
-
- --- Je vois pas comment déclarer une variable (utiliser Vardecl qui demande un tp * vname) 
-     qui renvoie un type vardecl avec Assign qui demande vname * expr ( et qui renvoie un com) 
-
-     pour pouvoir prendre en compte "int x = 15;" par exemple
-
-
  ---Comment ça marche pour appeler une fonction ou expressionn CallE et CallC ?
 
-
- ---|block_item_list_opt {$1} // peut etre fundefn plutot vu que c'est le vrai compound_statement
-
-     : d'apres la doc, fundefn c'est le compound_statement, mais il a pas le optionnel 
-
     associativité des opérateurs  ? (dans le pdf TP2 : introduction à YACC,  partie 4 --> développons la grammaire ---> tirer 2)
 */