feat: ajout de la grammaire correspondant aux pointeurs

src/lexer.mll

@@ -29,7 +29,9 @@
         "denom",   DENOM;
         "true",    TRUE;
         "false",   FALSE;
-        "return",  RETURN
+        "return",  RETURN;
+        "null",    NULL;
+        "new",     NEW;
       ];
     fun id ->
       match Hashtbl.find_opt kws id with
@@ -38,11 +40,14 @@
 }
 
 rule token = parse
-  (* ignore les sauts de lignes mais les compte quand même *)
+
+(* ignore les sauts de lignes mais les compte quand même *)
 | '\n'         { new_line lexbuf; token lexbuf }
-  (* ignore les espaces et tabulations *)
+
+(* ignore les espaces et tabulations *)
 | [' ' '\t']   { token lexbuf }
-  (* ignore les commentaires *)
+
+(* ignore les commentaires *)
 | "//"[^'\n']* { token lexbuf }
 
 (* caractères spéciaux de RAT *)
@@ -58,15 +63,16 @@ rule token = parse
 | "+"          { PLUS }
 | "*"          { MULT }
 | "<"          { INF }
+| "&"          { AMP }
 
 (* constantes entières *)
-| ("-")?['0'-'9']+ as i
-               { ENTIER (int_of_string i) }
+| ("-")?['0'-'9']+ as i                            { ENTIER (int_of_string i) }
+
 (* identifiants et mots-clefs *)
-| ['a'-'z'](['A'-'Z''a'-'z''0'-'9']|"-"|"_")* as n
-               { ident n }
+| ['a'-'z'](['A'-'Z''a'-'z''0'-'9']|"-"|"_")* as n { ident n }
 
 (* fin de lecture *)
 | eof          { EOF }
+
 (* entrée non reconnue *)
 | _            { error lexbuf }

src/out.tam

@@ -1,90 +0,0 @@
-; fichiersRat/src-rat-tam-test/testfun5.rat
-JUMP main
-
-pgcd
-LOADL 0
-LOAD (1) -2[LB]
-LOAD (1) -1[LB]
-boucle
-LOAD (1) 5[LB]
-JUMPIF (0) fin
-LOAD (1) 4[LB]
-LOAD (1) 5 [LB]
-SUBR IMod
-STORE (1) 3[LB]
-LOAD (1) 5[LB]
-STORE (1) 4[LB]
-LOAD (1) 3[LB]
-STORE(1) 5[LB]
-JUMP boucle
-fin
-LOAD (1) 4[LB]
-RETURN (1) 2
-
-norm
-LOAD (1) -2[LB]
-LOAD (1) -1[LB]
-CALL (LB) pgcd
-LOAD (1) -2[LB]
-LOAD (1) 3[LB]
-SUBR IDiv
-LOAD (1) -1[LB]
-LOAD (1) 3[LB]
-SUBR IDiv
-RETURN (2) 2
-
-ROut
-LOADL '['
-SUBR COut
-LOAD (1) -2[LB]
-SUBR IOut
-LOADL '/'
-SUBR COut
-LOAD (1) -1[LB]
-SUBR IOut
-LOADL ']'
-SUBR COut
-RETURN (0) 2
-
-RAdd
-LOAD (1) -4[LB]
-LOAD (1) -1[LB]
-SUBR IMul
-LOAD (1) -2[LB]
-LOAD (1) -3[LB]
-SUBR IMul
-SUBR IAdd
-LOAD (1) -3[LB]
-LOAD (1) -1[LB]
-SUBR IMul
-CALL (ST) norm
-RETURN (2) 4
-
-RMul
-LOAD (1) -4[LB]
-LOAD (1) -2[LB]
-SUBR IMul
-LOAD (1) -3[LB]
-LOAD (1) -1[LB]
-SUBR IMul
-CALL (ST) norm
-RETURN (2) 4
-
-f1
-PUSH 1
-LOAD (1) -1[LB]
-STORE (1) 3[LB]
-POP (1) 1
-LOADL ''
-RETURN (0) 1
-
-main
-PUSH 1
-LOADL 13
-CALL (ST) f1
-STORE (1) 0[SB]
-LOAD (1) 0[SB]
-SUBR IOut
-POP (0) 1
-
-HALT

src/parser.mly

@@ -1,12 +1,10 @@
 /* Imports. */
 
 %{
-
 open Type
 open Ast.AstSyntax
 %}
 
-
 %token <int> ENTIER
 %token <string> ID
 %token RETURN
@@ -37,6 +35,10 @@ open Ast.AstSyntax
 %token INF
 %token EOF
 
+%token NULL
+%token NEW
+%token AMP
+
 (* Type de l'attribut synthétisé des non-terminaux *)
 %type <programme> prog
 %type <instruction list> bloc
@@ -53,11 +55,11 @@ open Ast.AstSyntax
 
 %%
 
-main : lfi = prog EOF     {lfi}
+main : lfi=prog EOF     {lfi}
 
 prog :
-| lf = fonc  lfi = prog   {let (Programme (lf1,li))=lfi in (Programme (lf::lf1,li))}
-| ID li = bloc            {Programme ([],li)}
+| lf=fonc lfi=prog    {let (Programme (lf1,li))=lfi in (Programme (lf::lf1,li))}
+| ID li=bloc          {Programme ([],li)}
 
 fonc : t=typ n=ID PO p=dp PF AO li=is AF {Fonction(t,n,p,li)}
 
@@ -75,20 +77,21 @@ i :
 | IF exp=e li1=bloc ELSE li2=bloc   {Conditionnelle (exp,li1,li2)}
 | WHILE exp=e li=bloc               {TantQue (exp,li)}
 | RETURN exp=e PV                   {Retour (exp)}
+| a1=a EQUAL exp=e1                 {Affectation(Deref(a1), e1)}
 
 dp :
 |                         {[]}
 | t=typ n=ID lp=dp        {(t,n)::lp}
 
 typ :
-| BOOL    {Bool}
-| INT     {Int}
-| RAT     {Rat}
+| BOOL          {Bool}
+| INT           {Int}
+| RAT           {Rat}
+| t1=typ MULT   {Deref t1}
 
 e : 
 | CALL n=ID PO lp=cp PF   {AppelFonction (n,lp)}
 | CO e1=e SLASH e2=e CF   {Binaire(Fraction,e1,e2)}
-| n=ID                    {Ident n}
 | TRUE                    {Booleen true}
 | FALSE                   {Booleen false}
 | e=ENTIER                {Entier e}
@@ -99,8 +102,15 @@ e :
 | PO e1=e EQUAL e2=e PF   {Binaire (Equ,e1,e2)}
 | PO e1=e INF e2=e PF     {Binaire (Inf,e1,e2)}
 | PO exp=e PF             {exp}
+| a1=a                    {Affectable a1}
+| NULL                    { ??? }
+| PO NEW t1=typ PF        { ??? }
+| AMP n=ID                { Deref n }
 
 cp :
 |               {[]}
 | e1=e le=cp    {e1::le}
 
+a :
+| n=ID                {Ident n}
+| PO MULT a1=a PF     {Deref a1}