init: sources étu

.gitignore

@@ -0,0 +1 @@
+_build/

ast.ml

@@ -0,0 +1,188 @@
+open Type
+
+(* Interface des arbres abstraits *)
+module type Ast =
+sig
+   type expression
+   type instruction
+   type fonction
+   type programme
+end
+
+
+(* *************************************** *)
+(* AST après la phase d'analyse syntaxique *)
+(* *************************************** *)
+module AstSyntax =
+struct
+
+(* Opérateurs unaires de Rat *)
+type unaire = Numerateur | Denominateur
+
+(* Opérateurs binaires de Rat *)
+type binaire = Fraction | Plus | Mult | Equ | Inf
+
+(* Expressions de Rat *)
+type expression =
+  (* Appel de fonction représenté par le nom de la fonction et la liste des paramètres réels *)
+  | AppelFonction of string * expression list
+  (* Accès à un identifiant représenté par son nom *)
+  | Ident of string
+  (* Booléen *)
+  | Booleen of bool
+  (* Entier *)
+  | Entier of int
+  (* Opération unaire représentée par l'opérateur et l'opérande *)
+  | Unaire of unaire * expression
+  (* Opération binaire représentée par l'opérateur, l'opérande gauche et l'opérande droite *)
+  | Binaire of binaire * expression * expression
+
+(* Instructions de Rat *)
+type bloc = instruction list
+and instruction =
+  (* Déclaration de variable représentée par son type, son nom et l'expression d'initialisation *)
+  | Declaration of typ * string * expression
+  (* Affectation d'une variable représentée par son nom et la nouvelle valeur affectée *)
+  | Affectation of string * expression
+  (* Déclaration d'une constante représentée par son nom et sa valeur (entier) *)
+  | Constante of string * int
+  (* Affichage d'une expression *)
+  | Affichage of expression
+  (* Conditionnelle représentée par la condition, le bloc then et le bloc else *)
+  | Conditionnelle of expression * bloc * bloc
+  (*Boucle TantQue représentée par la conditin d'arrêt de la boucle et le bloc d'instructions *)
+  | TantQue of expression * bloc
+  (* return d'une fonction *)
+  | Retour of expression
+
+(* Structure des fonctions de Rat *)
+(* type de retour - nom - liste des paramètres (association type et nom) - corps de la fonction *)
+type fonction = Fonction of typ * string * (typ * string) list * bloc
+
+(* Structure d'un programme Rat *)
+(* liste de fonction - programme principal *)
+type programme = Programme of fonction list * bloc
+
+end
+
+
+(* ********************************************* *)
+(* AST après la phase d'analyse des identifiants *)
+(* ********************************************* *)
+module AstTds =
+struct
+
+  (* Expressions existantes dans notre langage *)
+  (* ~ expression de l'AST syntaxique où les noms des identifiants ont été
+  remplacés par les informations associées aux identificateurs *)
+  type expression =
+    | AppelFonction of Tds.info_ast * expression list
+    | Ident of Tds.info_ast (* le nom de l'identifiant est remplacé par ses informations *)
+    | Booleen of bool
+    | Entier of int
+    | Unaire of AstSyntax.unaire * expression
+    | Binaire of AstSyntax.binaire * expression * expression
+
+  (* instructions existantes dans notre langage *)
+  (* ~ instruction de l'AST syntaxique où les noms des identifiants ont été
+  remplacés par les informations associées aux identificateurs
+  + suppression de nœuds (const) *)
+  type bloc = instruction list
+  and instruction =
+    | Declaration of typ * Tds.info_ast * expression (* le nom de l'identifiant est remplacé par ses informations *)
+    | Affectation of  Tds.info_ast * expression (* le nom de l'identifiant est remplacé par ses informations *)
+    | Affichage of expression
+    | Conditionnelle of expression * bloc * bloc
+    | TantQue of expression * bloc
+    | Retour of expression
+    | Empty (* les nœuds ayant disparus: Const *)
+
+
+  (* Structure des fonctions dans notre langage *)
+  (* type de retour - informations associées à l'identificateur (dont son nom) - liste des paramètres (association type et information sur les paramètres) - corps de la fonction *)
+  type fonction = Fonction of typ * Tds.info_ast * (typ * Tds.info_ast ) list * bloc
+
+  (* Structure d'un programme dans notre langage *)
+  type programme = Programme of fonction list * bloc
+
+end
+
+
+(* ******************************* *)
+(* AST après la phase de typage *)
+(* ******************************* *)
+module AstType =
+struct
+
+(* Opérateurs unaires de Rat - résolution de la surcharge *)
+type unaire = Numerateur | Denominateur
+
+(* Opérateurs binaires existants dans Rat - résolution de la surcharge *)
+type binaire = Fraction | PlusInt | PlusRat | MultInt | MultRat | EquInt | EquBool | Inf
+
+(* Expressions existantes dans Rat *)
+(* = expression de AstTds *)
+type expression =
+  | AppelFonction of Tds.info_ast * expression list
+  | Ident of Tds.info_ast
+  | Booleen of bool
+  | Entier of int
+  | Unaire of unaire * expression
+  | Binaire of binaire * expression * expression
+
+(* instructions existantes Rat *)
+(* = instruction de AstTds + informations associées aux identificateurs, mises à jour *)
+(* + résolution de la surcharge de l'affichage *)
+type bloc = instruction list
+ and instruction =
+  | Declaration of Tds.info_ast * expression
+  | Affectation of Tds.info_ast * expression
+  | AffichageInt of expression
+  | AffichageRat of expression
+  | AffichageBool of expression
+  | Conditionnelle of expression * bloc * bloc
+  | TantQue of expression * bloc
+  | Retour of expression
+  | Empty (* les nœuds ayant disparus: Const *)
+
+(* informations associées à l'identificateur (dont son nom), liste des paramètres, corps *)
+type fonction = Fonction of Tds.info_ast * Tds.info_ast list * bloc
+
+(* Structure d'un programme dans notre langage *)
+type programme = Programme of fonction list * bloc
+
+let taille_variables_declarees i =
+  match i with
+  | Declaration (info,_) ->
+    begin
+    match Tds.info_ast_to_info info with
+    | InfoVar (_,t,_,_) -> getTaille t
+    | _ -> failwith "internal error"
+    end
+  | _ -> 0 ;;
+
+end
+
+(* ******************************* *)
+(* AST après la phase de placement *)
+(* ******************************* *)
+module AstPlacement =
+struct
+
+(* Expressions existantes dans notre langage *)
+(* = expression de AstType  *)
+type expression = AstType.expression
+
+(* instructions existantes dans notre langage *)
+(* = instructions de AstType  *)
+type bloc = instruction list
+ and instruction = AstType.instruction
+
+(* informations associées à l'identificateur (dont son nom), liste de paramètres, corps, expression de retour *)
+(* Plus besoin de la liste des paramètres mais on la garde pour les tests du placements mémoire *)
+type fonction = Fonction of Tds.info_ast * Tds.info_ast list * bloc
+
+(* Structure d'un programme dans notre langage *)
+type programme = Programme of fonction list * bloc
+
+end

code.ml

@@ -0,0 +1,100 @@
+(* Génération d'étiquette à l'aide d'un compteur *)
+let getEtiquette = 
+  let num = ref 0 in
+  fun () ->
+    num := (!num)+1 ;
+    "label"^((string_of_int (!num)))
+
+let pgcd = 
+"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\n\n"
+
+let norm =
+"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\n\n"
+
+let rout =
+"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\n\n"
+
+let radd =
+"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\n\n"
+
+let rmul =
+"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\n\n"
+
+(* Entête des fichiers Rat  contenant :
+- un saut vers le programme principal
+- la fonction pgcd nécessaire à la normalisation des rationnels
+- une fonction de normalisation des rationnels
+- les fonctions d'affichage (ROut), d'addition (RAdd) et de multiplication (RMult) de rationnel
+*)
+let getEntete () =
+  "JUMP main\n\n"
+  ^pgcd
+  ^norm
+  ^rout
+  ^radd
+  ^rmul
+
+(*Ecriture dans un fichier *)
+let ecrireFichier nom texte =
+  let fich = open_out nom in
+  output_string fich texte ;
+  close_out fich

code.mli

@@ -0,0 +1,15 @@
+(* getEtiquette : unit -> string *)
+(* Renvoie une étiquette TAM *)
+(* Chaque appel donne une étiquette différente *)
+val getEtiquette : unit -> string ;;
+
+(* getEntete : unit -> string *)
+(* Renvoie ce qui doit être mis en entête du fichier TAM *)
+val getEntete : unit -> string ;;
+
+(* ecrireFichier : string -> string -> unit *)
+(* écrit une chaîne de caractère dans un fichier *)
+(* Premier paramètre : le nom du fichier *)
+(* Second paramètre : le texte à écrire *)
+(* Erreur si le fichier ne peut pas être écrit (nom invalide, permissions insuffisantes) *)
+val ecrireFichier : string -> string -> unit ;;

compilateur.ml

@@ -0,0 +1,112 @@
+open Passe
+
+(* Définition d'un compilateur comme l'enchaînement de 
+quatre passes (gestion des identifiants, typage, placement mémoire
+génération de code). Chaque passe prend en entrée le type de
+sortie de la passe précédente.
+La dernière passe doit renvoyer une chaîne de caractères (le code généré)
+*)
+module Compilateur (Ptds:Passe) 
+                    (Ptype:Passe with type t1 = Ptds.t2) 
+                    (Pdep:Passe with type t1 = Ptype.t2) 
+                    (Pcode:Passe with type t1 = Pdep.t2 and type t2 = string) : 
+                    Passe with type t1 = Ptds.t1 and type t2 = string =
+struct
+  
+  type t1 = Ptds.t1
+  type t2 = string
+
+(* analyse_semantique : ast -> string *)
+(* Réalise l'analyse sémantique de l'arbre abstrait *)
+(* en appliquant les passes les unes après les autres *)
+(* retourne : le code issu de la dernière passe *)
+  let analyser ast =
+    let tast = Ptds.analyser ast in
+    let tyast = Ptype.analyser tast in
+    let past = Pdep.analyser tyast in
+    let code = Pcode.analyser past in
+    code
+end
+
+
+(* Compilateurs intermédiaires *)
+
+
+(* Compilateur créant l'AST *)
+(*
+module CompilateurRat = Compilateur (PasseTdsNop) (PasseNop) (PasseNop) (PasseCodeNopNop)
+*)
+
+(* + passe de résolution des identifiants *)
+open PasseTdsRat
+module CompilateurRat = Compilateur (PasseTdsRat) (PasseTypeNop) (PasseNop) (PasseCodeNopNop) 
+
+(* + passe de typage *)
+(*
+open PasseTdsRat
+open PasseTypeRat
+module CompilateurRat = Compilateur (PasseTdsRat) (PasseTypeRat) (PassePlacementNop) (PasseCodeNopNop)
+*)
+
+(* + passe de placement mémoire *)
+(*
+open PasseTdsRat
+open PasseTypeRat
+open PassePlacementRat
+module CompilateurRat = Compilateur (PasseTdsRat) (PasseTypeRat) (PassePlacementRat) (PasseCodeNop)
+*)
+
+(* + passe de génération de code -> compilateur complet *)
+(*
+open PasseTdsRat
+open PasseTypeRat
+open PassePlacementRat
+open PasseCodeRatToTam
+module CompilateurRat = Compilateur (PasseTdsRat) (PasseTypeRat) (PassePlacementRat) (PasseCodeRatToTam)
+*)
+
+
+open Lexing
+
+
+(* report_error : string -> Lexing.lexbuf -> string -> unit *)
+(* Affiche un message d'erreur lorsque le fichier n'est pas conforme à la grammaire *)
+(* filename : le nom du fichier non conforme *)
+(* lexbuf : l'analyser lexical *)
+(* msg : le message d'erreur à afficher *)
+let report_error filename lexbuf msg =
+ let (b,e) = (lexeme_start_p lexbuf, lexeme_end_p lexbuf) in
+ let fc = b.pos_cnum - b.pos_bol + 1 in
+ let lc = e.pos_cnum - b.pos_bol + 1 in
+  Printf.eprintf "File \"%s\", line %d, characters %d-%d: %s\n" filename b.pos_lnum fc lc msg
+
+
+(* compiler : string -> string *)
+(* Compilter un code rat en un code TAM *)
+(* Paramètre ratfile : le nom du fichier rat à compiler *)
+(* Utilise le compilateur "CompilateurRat" pour générer le code associé au fichier rat *)
+(* Erreur si soucis lors de l'analyse lexicale, l'analyse syntaxique,
+ mauvaise utilisation des identifiants ou soucis de typage *)
+let compiler ratfile =
+  let input = open_in ratfile in
+  let filebuf = Lexing.from_channel input in
+  try
+    let ast = Parser.main Lexer.token filebuf in
+    "; " ^ ratfile ^ "\n" ^ (CompilateurRat.analyser ast)
+  with
+  | Lexer.Error _ as e ->
+      report_error ratfile filebuf "lexical error (unexpected character).";
+      raise e
+  | Parser.Error as e->
+      report_error ratfile filebuf "syntax error.";
+      raise e
+
+(* compilerVersFichier : string -> string -> () *)
+(* Compiler un code rat en un code TAM et le sauve dans un fichier *)
+(* ratfile : le nom du fichier rat à compiler *)
+(* tamfile : le nom du fichier rat où sauver le résultat *)
+let compilerVersFichier ratfile tamfile =
+   let tamcode = compiler ratfile in
+   let chan = open_out tamfile in
+   output_string chan tamcode;
+   close_out chan

dune

@@ -0,0 +1,11 @@
+(ocamllex lexer)
+
+(menhir
+ (modules parser))
+
+(library
+ (name rat)
+ (libraries unix)
+ (inline_tests)
+ (preprocess
+  (pps ppx_inline_test ppx_expect)))

dune-project

@@ -0,0 +1,2 @@
+(lang dune 2.9)
+(using menhir 2.1)

dune-workspace

@@ -0,0 +1,2 @@
+(lang dune 2.9)
+(env (dev (flags (:standard -warn-error -A))))

exceptions.ml

@@ -0,0 +1,13 @@
+open Type
+open Ast.AstSyntax
+
+(* Exceptions pour la gestion des identificateurs *)
+exception DoubleDeclaration of string 
+exception IdentifiantNonDeclare of string 
+exception MauvaiseUtilisationIdentifiant of string 
+
+(* Exceptions pour le typage *)
+(* Le premier type est le type réel, le second est le type attendu *)
+exception TypeInattendu of typ * typ
+exception TypesParametresInattendus of typ list * typ list
+exception TypeBinaireInattendu of binaire * typ * typ (* les types sont les types réels non compatible avec les signatures connues de l'opérateur *)

fichiersRat/examen-20-21/ex1.rat

@@ -0,0 +1,13 @@
+int f (int a){
+ if (a=3){
+   rat a = [3/2];
+   print a;
+ }else{
+   print a;
+ }
+ return 0;
+}
+
+main {
+    print (call f (1));
+}

fichiersRat/examen-20-21/ex2.rat

@@ -0,0 +1,9 @@
+int f (int a){
+ rat a = [3/2];
+ print a;
+ return 0;
+}
+
+main {
+    print (call f (1));
+}

fichiersRat/src-rat-placement-test/test1.rat

@@ -0,0 +1,3 @@
+main {
+    int x = 0;
+}

fichiersRat/src-rat-placement-test/test10.rat

@@ -0,0 +1,7 @@
+rat f (rat a) {
+    return a;
+}
+
+
+main {
+}

fichiersRat/src-rat-placement-test/test11.rat

@@ -0,0 +1,7 @@
+bool f (bool a) {
+    return a;
+}
+
+
+main {
+}

fichiersRat/src-rat-placement-test/test12.rat

@@ -0,0 +1,7 @@
+bool f (bool b rat r int i) {
+    return b;
+}
+
+
+main {
+}

fichiersRat/src-rat-placement-test/test2.rat

@@ -0,0 +1,5 @@
+main {
+    int x = 0;
+    int y = 0;
+    int z = 0;
+}

fichiersRat/src-rat-placement-test/test3.rat

@@ -0,0 +1,5 @@
+main {
+    bool x = true;
+    bool y = true;
+    bool z = true;
+}

fichiersRat/src-rat-placement-test/test4.rat

@@ -0,0 +1,5 @@
+main {
+    rat x = [0/1];
+    rat y = [0/1];
+    rat z = [0/1];
+}

fichiersRat/src-rat-placement-test/test5.rat

@@ -0,0 +1,5 @@
+main {
+    bool x = true;
+    rat y = [0/1];
+    int z = 0;
+}

fichiersRat/src-rat-placement-test/test6.rat

@@ -0,0 +1,17 @@
+main {
+    bool x = true;
+    rat y = [0/1];
+    int z = 0;
+    if x {
+       bool x = true;
+       rat y = [0/1];
+       int z = 0;
+    } else {
+       bool x = true;
+       rat y = [0/1];
+       int z = 0;
+    }
+    bool x1 = true;
+    rat y1 = [0/1];
+    int z1 = 0;
+}

fichiersRat/src-rat-placement-test/test7.rat

@@ -0,0 +1,13 @@
+main {
+    bool x = true;
+    rat y = [0/1];
+    int z = 0;
+    while x {
+       bool x = true;
+       rat y = [0/1];
+       int z = 0;
+    } 
+    bool x1 = true;
+    rat y1 = [0/1];
+    int z1 = 0;
+}

fichiersRat/src-rat-placement-test/test8.rat

@@ -0,0 +1,29 @@
+int f (int a) {
+    bool x = true;
+    rat y = [0/1];
+    int z = 0;
+    while x {
+       bool x = true;
+       rat y = [0/1];
+       int z = 0;
+    } 
+    bool x1 = true;
+    rat y1 = [0/1];
+    int z1 = 0;
+    return 0;
+}
+
+
+main {
+    bool x = true;
+    rat y = [0/1];
+    int z = 0;
+    while x {
+       bool x = true;
+       rat y = [0/1];
+       int z = 0;
+    } 
+    bool x1 = true;
+    rat y1 = [0/1];
+    int z1 = 0;
+}

fichiersRat/src-rat-placement-test/test9.rat

@@ -0,0 +1,7 @@
+int f (int a) {
+    return a;
+}
+
+
+main {
+}

fichiersRat/src-rat-tam-test/complique.rat

@@ -0,0 +1,10 @@
+prog {
+  const a = 5;
+  rat x = [6/a];
+  int y = (a+1);
+  x = (x + [3/2]);
+  while (y < 10) {
+    print ([a/y] * x);
+    y = (y + 1);
+  }
+}

fichiersRat/src-rat-tam-test/factiter.rat

@@ -0,0 +1,10 @@
+fact {
+     const n = 5;
+     int fact = 1;
+     int i = 1;
+     while (i < (n+1)) {
+         fact = (fact * i);
+         i = (i + 1);
+     }
+     print fact;
+}

fichiersRat/src-rat-tam-test/factrec.rat

@@ -0,0 +1,14 @@
+int fact (int i int n){
+  int res = 0;
+  if (i=n){
+    res = i;
+  } else {
+    res = ( i * call fact ((i+1) n));
+  }
+  return res;
+}
+
+test{
+  int x = call fact (1 5);
+  print x;
+}

fichiersRat/src-rat-tam-test/test.rat

@@ -0,0 +1,3 @@
+test{
+   print 1;
+}

fichiersRat/src-rat-tam-test/testaddint.rat

@@ -0,0 +1,3 @@
+main {
+  print (20+22);
+}

fichiersRat/src-rat-tam-test/testaddrat.rat

@@ -0,0 +1,3 @@
+main {
+  print ([1/2] + [2/3]);
+}

fichiersRat/src-rat-tam-test/testdenom.rat

@@ -0,0 +1,4 @@
+main {
+  rat x = [4/7];
+  print denom x;
+}

fichiersRat/src-rat-tam-test/testfun1.rat

@@ -0,0 +1,7 @@
+int f (){
+  return 1;
+}
+
+test{
+  print call f ();
+}

fichiersRat/src-rat-tam-test/testfun2.rat

@@ -0,0 +1,7 @@
+int f (int a){
+  return a;
+}
+
+test{
+  print call f ((3+4));
+}

fichiersRat/src-rat-tam-test/testfun3.rat

@@ -0,0 +1,7 @@
+int f (int a int b){
+  return (a+b);
+}
+
+test{
+  print call f ((3+4) 3);
+}

fichiersRat/src-rat-tam-test/testfun4.rat

@@ -0,0 +1,9 @@
+int f (int a int b){
+  return (a+b);
+}
+
+test{
+  int c = (3+4);
+  int d = 3;
+  print call f (c d);
+}

fichiersRat/src-rat-tam-test/testfun5.rat

@@ -0,0 +1,8 @@
+int f1 (int i){
+ int x = i;
+}
+
+test{
+  int x = call f1 (13);
+  print x;
+}

fichiersRat/src-rat-tam-test/testfun6.rat

@@ -0,0 +1,38 @@
+bool and (bool b1 bool b2){
+  if b1 {
+    if b2 { return true; }
+    else { return false; }
+  } else {
+    return false;
+  }
+}
+
+bool or (bool b1 bool b2){
+  if b1 {
+    return true;
+  } else {
+    if b2 { return true; }
+    else { return false; }
+  }
+}
+
+bool not (bool b) {
+  if b { return false; } else { return true; }
+}
+
+bool implies (bool p bool q) {
+  return (call or((call not (p)) q));
+}
+
+bool veriftranspose(bool a bool b){
+  return ((call implies(a b)) = (call implies((call not(b)) (call not(a)))));
+}
+
+test{
+  bool a = true;
+  bool b = true;
+  print (call veriftranspose(a b));
+  a = true;
+  b = false;
+  print (call veriftranspose(a b));
+}

fichiersRat/src-rat-tam-test/testfuns.rat

@@ -0,0 +1,20 @@
+rat f3 (int a int b rat r){
+  return [(a + num r) / (b + denom r)];
+}
+
+rat f2 (bool b rat x rat y){
+  int x1 = num x;
+  int x2 = denom x;
+  rat res = call f3(x1 x2 y);
+  return res;
+}
+
+int f1 (int i rat r int n){
+  rat r2 = call f2(true r [i/n]);
+  return denom r2;
+}
+
+test{
+  int x = call f1 (13 [4/11] 17);
+  print x;
+}

fichiersRat/src-rat-tam-test/testif1.rat

@@ -0,0 +1,9 @@
+prog {
+  int x = 1;
+  int y = 1;
+  if (x = y) {
+    print 18;
+  } else {
+    print 21;
+  }
+}

fichiersRat/src-rat-tam-test/testif2.rat

@@ -0,0 +1,9 @@
+prog {
+  int x = 1;
+  int y = 2;
+  if (x = y) {
+    print 18;
+  } else {
+    print 21;
+  }
+}

fichiersRat/src-rat-tam-test/testmultint.rat

@@ -0,0 +1,3 @@
+main {
+  print (20 * 22);
+}

fichiersRat/src-rat-tam-test/testmultrat.rat

@@ -0,0 +1,3 @@
+main {
+  print ([7/2] * [4/3]);
+}

fichiersRat/src-rat-tam-test/testnum.rat

@@ -0,0 +1,4 @@
+main {
+  rat x = [4/7];
+  print num x;
+}

fichiersRat/src-rat-tam-test/testprintbool.rat

@@ -0,0 +1,3 @@
+main {
+  print true;
+}

fichiersRat/src-rat-tam-test/testprintint.rat

@@ -0,0 +1,3 @@
+main {
+  print 42;
+}

fichiersRat/src-rat-tam-test/testprintrat.rat

@@ -0,0 +1,3 @@
+main {
+  print [4/5];
+}

fichiersRat/src-rat-tam-test/testwhile1.rat

@@ -0,0 +1,9 @@
+prog {
+  int x = 1;
+  int y = 1;
+  while (y < 10) {
+    x = (x + 2);
+    y = (y + 1);
+  }
+  print x;
+}

fichiersRat/src-rat-tds-test/test.rat

@@ -0,0 +1,18 @@
+int add (int a int b){
+  int c = 0;
+  c = (0 + a);
+  return (a+(b+c));}
+
+test{
+  int x = 3;
+  x = 4;
+  const y = 5;
+  int z = (x+y);
+  if(x<0){
+    bool x1 = true;
+    x1 = false;
+  }else{
+    rat x2 = [4/3];
+    int e = call add (num x2 y);
+  }
+}

fichiersRat/src-rat-tds-test/test2.rat

@@ -0,0 +1,10 @@
+int plus1 (int a int b){
+  int c = 1;
+  return (a+(b+c));
+}
+
+fonction{
+  int x = 3;
+  int y = 4;
+  print call plus1 (x y);
+}

fichiersRat/src-rat-tds-test/testAffectation1.rat

@@ -0,0 +1,4 @@
+test{
+  int x = 3;
+  x = 4; 
+}

fichiersRat/src-rat-tds-test/testAffectation2.rat

@@ -0,0 +1,4 @@
+test{
+  int x = 3;
+  y = 4; 
+}

fichiersRat/src-rat-tds-test/testAffectation3.rat

@@ -0,0 +1,8 @@
+test{
+  int x = 3;
+  if (x = 3){
+    x = 4;
+  } else {
+    x = 6;
+  } 
+}

fichiersRat/src-rat-tds-test/testAffectation4.rat

@@ -0,0 +1,8 @@
+test{
+  const x = 3;
+  if (x = 3){
+    x = 4;
+  } else {
+    x = 6;
+  } 
+}

fichiersRat/src-rat-tds-test/testAffectation5.rat

@@ -0,0 +1,11 @@
+int add (int a int b){
+  return (a+b);
+ }
+ 
+int add2 (int a int b ){
+  return (a+b);
+ }
+
+test{
+  add = add2;
+}

fichiersRat/src-rat-tds-test/testDeclarationFonction.rat

@@ -0,0 +1,11 @@
+int add (int a int b){
+  return (a+b);
+ }
+ 
+int add2 (int a int b ){
+  return (a+b);
+ }
+
+test{
+  int x = 3;
+}

fichiersRat/src-rat-tds-test/testDoubleDeclarationFonction.rat

@@ -0,0 +1,11 @@
+int add (int a int b){
+  return (a+b);
+ }
+ 
+int add (int a int b ){
+  return (a+b);
+ }
+
+test{
+  int x = 3;
+}

fichiersRat/src-rat-tds-test/testDoubleDeclarationParametre1.rat

@@ -0,0 +1,11 @@
+int add (int a int a){
+  return (a+2);
+ }
+ 
+int add2 (int a int b ){
+  return (a+b);
+ }
+
+test{
+  int x = 3;
+}

fichiersRat/src-rat-tds-test/testDoubleDeclarationParametre2.rat

@@ -0,0 +1,11 @@
+int add (int a int b){
+  return (a+b);
+ }
+ 
+int add2 (int a int b int a){
+  return (a+b);
+ }
+
+test{
+  int x = 3;
+}

fichiersRat/src-rat-tds-test/testDoubleDeclarationVariable1.rat

@@ -0,0 +1,13 @@
+int add (int a int b){
+  int x = 1;
+  int x = 2;
+  return (a+b);
+ }
+ 
+int add2 (int a int b ){
+  return (a+b);
+ }
+
+test{
+  int x = 3;
+}

fichiersRat/src-rat-tds-test/testDoubleDeclarationVariable2.rat

@@ -0,0 +1,16 @@
+int add (int a int b){
+  return (a+b);
+ }
+ 
+int add2 (int a int b ){
+  return (a+b);
+ }
+
+test{
+  int x = 3;
+  if (x < 3){
+    rat x = [4/2];
+  }else{
+    rat x = [1/3];
+  }
+}

fichiersRat/src-rat-tds-test/testDoubleDeclarationVariable3.rat

@@ -0,0 +1,16 @@
+int add (int a int b){
+  return (a+b);
+ }
+ 
+int add2 (int a int b ){
+  return (a+b);
+ }
+
+test{
+  int x = 3;
+  if (x < 3){
+    rat x = [4/2];
+  }else{
+    bool x = false;
+  }
+}

fichiersRat/src-rat-tds-test/testDoubleDeclarationVariable4.rat

@@ -0,0 +1,12 @@
+int add (int a int b){
+  return (a+b);
+ }
+ 
+int add2 (int a int b ){
+  return (a+b);
+ }
+
+test{
+  const x = 3;
+  const x = 4;
+}

fichiersRat/src-rat-tds-test/testDoubleDeclarationVariable5.rat

@@ -0,0 +1,17 @@
+int add (int a int b){
+  return (a+b);
+ }
+ 
+int add2 (int a int b ){
+  return (a+b);
+ }
+
+test{
+  int y = 3;
+  if (y=1){
+    const x = 3;
+    const x = 4;
+  }else{
+    print y;
+  }
+}

fichiersRat/src-rat-tds-test/testDoubleDeclarationVariable6.rat

@@ -0,0 +1,15 @@
+int add (int a int b){
+  return (a+b);
+ }
+ 
+int add2 (int a int b ){
+  return (a+b);
+ }
+
+test{
+  int y = 3;
+  while (y=1){
+    const x = 3;
+    int x = 4;
+  }
+}

fichiersRat/src-rat-tds-test/testDoubleDeclarationVariable7.rat

@@ -0,0 +1,15 @@
+int add (int a int b){
+  return (a+b);
+ }
+ 
+int add2 (int a int b ){
+  return (a+b);
+ }
+
+test{
+  int y = 3;
+  while (y=1){
+    const x = 3;
+    const x = 4;
+  }
+}

fichiersRat/src-rat-tds-test/testRecursiviteFonction.rat

@@ -0,0 +1,14 @@
+int fact (int i int n){
+  int res = 0;
+  if (i=n){
+    res = i;
+  } else {
+    res = ( i * call fact ((i+1) n));
+  }
+  return res;
+}
+
+test{
+  int x = call fact (1 5);
+  print x;
+}

fichiersRat/src-rat-tds-test/testRecursiviteVariable.rat

@@ -0,0 +1,3 @@
+test{
+  int x = (x+1);
+}

fichiersRat/src-rat-tds-test/testUtilisation1.rat

@@ -0,0 +1,4 @@
+test{
+  int x = 3;
+  int y = x; 
+}

fichiersRat/src-rat-tds-test/testUtilisation10.rat

@@ -0,0 +1,3 @@
+test{
+  print x;
+}

fichiersRat/src-rat-tds-test/testUtilisation11.rat

@@ -0,0 +1,3 @@
+test{
+  int x = num z;
+}

fichiersRat/src-rat-tds-test/testUtilisation12.rat

@@ -0,0 +1,3 @@
+test{
+  int x = denom z;
+}

fichiersRat/src-rat-tds-test/testUtilisation13.rat

@@ -0,0 +1,3 @@
+test{
+  int x = denom z;
+}

fichiersRat/src-rat-tds-test/testUtilisation14.rat

@@ -0,0 +1,3 @@
+test{
+  int x = [4/z];
+}

fichiersRat/src-rat-tds-test/testUtilisation15.rat

@@ -0,0 +1,3 @@
+test{
+  int x = [z/4];
+}

fichiersRat/src-rat-tds-test/testUtilisation16.rat

@@ -0,0 +1,3 @@
+test{
+  int x = (1+y);
+}

fichiersRat/src-rat-tds-test/testUtilisation17.rat

@@ -0,0 +1,3 @@
+test{
+  int x = (1+(2+y));
+}

fichiersRat/src-rat-tds-test/testUtilisation18.rat

@@ -0,0 +1,3 @@
+test{
+  bool x = (y=1);
+}

fichiersRat/src-rat-tds-test/testUtilisation19.rat

@@ -0,0 +1,3 @@
+test{
+  int x = (y+1);
+}

fichiersRat/src-rat-tds-test/testUtilisation2.rat

@@ -0,0 +1,8 @@
+test{
+  int x = 3;
+  if (x=3){
+    int y = x; 
+  }else{
+    int y = (x + 5);
+  }
+}

fichiersRat/src-rat-tds-test/testUtilisation20.rat

@@ -0,0 +1,7 @@
+int add (int x int y){
+  return (x+y);
+}
+
+test{
+  int x = call add (1 y);
+}

fichiersRat/src-rat-tds-test/testUtilisation21.rat

@@ -0,0 +1,7 @@
+int add (int x int y){
+  return (x+y);
+}
+
+test{
+  int x = call add (1 call add (1 y));
+}

fichiersRat/src-rat-tds-test/testUtilisation22.rat

@@ -0,0 +1,7 @@
+int add (int x int y){
+  return (x+y);
+}
+
+test{
+  int x = call add ((y+1) 2);
+}

fichiersRat/src-rat-tds-test/testUtilisation23.rat

@@ -0,0 +1,11 @@
+int add (int x int y){
+  return (x+y);
+}
+
+test{
+   if x {
+     int y = 4;
+   } else {
+     int y = 5;
+   } 
+}

fichiersRat/src-rat-tds-test/testUtilisation24.rat

@@ -0,0 +1,9 @@
+int add (int x int y){
+  return (x+y);
+}
+
+test{
+    while x {
+     int y = 4;
+   } 
+}

fichiersRat/src-rat-tds-test/testUtilisation25.rat

@@ -0,0 +1,7 @@
+int add (int x int y){
+  return a;
+}
+
+test{
+   int x = 1;
+}

fichiersRat/src-rat-tds-test/testUtilisation26.rat

@@ -0,0 +1,8 @@
+int add (int x int y){
+  int z = a;
+  return (x+z);
+}
+
+test{
+   int x = 1;
+}

fichiersRat/src-rat-tds-test/testUtilisation27.rat

@@ -0,0 +1,9 @@
+int add (int x int y){
+  int z = y;
+  return (x+z);
+}
+
+test{
+   int x = 1;
+   print call add (x x);
+}

fichiersRat/src-rat-tds-test/testUtilisation3.rat

@@ -0,0 +1,4 @@
+test{
+  int x = 3;
+  int z = y;
+}

fichiersRat/src-rat-tds-test/testUtilisation4.rat

@@ -0,0 +1,8 @@
+int add (int a int b){
+  return (a+b);
+ }
+
+test{
+  int x = 3;
+  int z = add;
+}

fichiersRat/src-rat-tds-test/testUtilisation5.rat

@@ -0,0 +1,8 @@
+int add (int a int b){
+  return (a+b);
+ }
+
+test{
+  int x = 3;
+  int z = (add+1);
+}

fichiersRat/src-rat-tds-test/testUtilisation6.rat

@@ -0,0 +1,8 @@
+int add (int a int b){
+  return (a+b);
+ }
+
+test{
+  const x = 3;
+  int z = (x+1);
+}

fichiersRat/src-rat-tds-test/testUtilisation7.rat

@@ -0,0 +1,9 @@
+int add (int a int b){
+  return (a+b);
+ }
+
+test{
+  const x = 3;
+  rat z = [4/2];
+  int r = call add ((x+1) num z);
+}

fichiersRat/src-rat-tds-test/testUtilisation8.rat

@@ -0,0 +1,9 @@
+int add (int a int b){
+  return (a+b);
+ }
+
+test{
+  const x = 3;
+  rat z = [4/2];
+  int r = call x ((x+1) num z);
+}

fichiersRat/src-rat-tds-test/testUtilisation9.rat

@@ -0,0 +1,9 @@
+int add (int a int b){
+  return (a+b);
+ }
+
+test{
+  const x = 3;
+  rat z = [4/2];
+  int r = call z ((x+1) num z);
+}

fichiersRat/src-rat-type-test/test.rat

@@ -0,0 +1,18 @@
+int add (int a int b){
+  int c = 0;
+  c = (0 + a);
+  return (a+(b+c));}
+
+test{
+  int x = 3;
+  x = 4;
+  const y = 5;
+  int z = (x+y);
+  if(x<0){
+    bool x = true;
+    x = false;
+  }else{
+    rat x = [4/3];
+    int e = call add (num x y);
+  }
+}

fichiersRat/src-rat-type-test/test2.rat

@@ -0,0 +1,10 @@
+int plus1 (int a int b){
+  int c = 1;
+  return (a+(b+c));
+}
+
+fonction{
+  int x = 3;
+  int y = 4;
+  print call plus1 (x y);
+}

fichiersRat/src-rat-type-test/testAffectation1.rat

@@ -0,0 +1,4 @@
+test{
+  int x = 3;
+  x = 4;
+}

fichiersRat/src-rat-type-test/testAffectation2.rat

@@ -0,0 +1,4 @@
+test{
+  bool x = true;
+  x = false;
+}

fichiersRat/src-rat-type-test/testAffectation3.rat

@@ -0,0 +1,4 @@
+test{
+  rat x = [3/4];
+  x = [4/5];
+}

fichiersRat/src-rat-type-test/testAffectation4.rat

@@ -0,0 +1,4 @@
+test{
+  rat x = [3/4];
+  x = 4;
+}

fichiersRat/src-rat-type-test/testAffectation5.rat

@@ -0,0 +1,4 @@
+test{
+  int x = 4;
+  x = true;
+}